<!DOCTYPE html>
<html>
<head hexo-theme='https://volantis.js.org/#'>
  <meta charset="utf-8">
  <!-- SEO相关 -->
  
    
  
  <!-- 渲染优化 -->
  <meta name="renderer" content="webkit">
  <meta name="force-rendering" content="webkit">
  <meta http-equiv="X-UA-Compatible" content="IE=Edge,chrome=1">
  <meta name="HandheldFriendly" content="True" >
  <meta name="apple-mobile-web-app-capable" content="yes">
  <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
  <meta name="baidu-site-verification" content="hZiKlANZ5f" />
  <!-- 页面元数据 -->
  
    <title>操作系统笔记 - CyChan&#39;s Blog</title>
  
    <meta name="keywords" content="操作系统">
  
  
    <meta name="description" content="1.阻塞/非阻塞IO,同步IO/异步IO，IO多路复用1. IO请求的两个阶段：

等待资源阶段：IO请求一般需要请求特殊的资源（如磁盘、RAM、文件），当资源被上一个使用者使用没有被释放时，IO请求就会被阻塞，直到能够使用这个资源。
使用资源阶段：真正进行数据接收和发送，即数据在内核空间和数据空间之间的移动。
">
  

  <!-- feed -->
  
    <link rel="alternate" href="/atom.xml" title="CyChan's Blog">
  

  <!-- import meta -->
  

  <!-- link -->
  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@fortawesome/fontawesome-free@5.13/css/all.min.css">
  
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@fancyapps/fancybox@3.5.7/dist/jquery.fancybox.min.css">

  
  
    
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/node-waves@0.7.6/dist/waves.min.css">

  

  
  <link rel="shortcut icon" type='image/x-icon' href="https://gitee.com/CyChan811/BlogImage/raw/master/img/头像.jpg">
  

  
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/aplayer@1.10/dist/APlayer.min.css">
  

  

  <!-- import link -->
  

  
  
    
<link rel="stylesheet" href="/css/style.css">

  

  <script>
    function setLoadingBarProgress(num) {
      document.getElementById('loading-bar').style.width=num+"%";
    }
  </script>

  
  
</head>

<body>
  
  <div id="loading-bar-wrapper">
  <div id="loading-bar"></div>
</div>
<header class="l_header shadow blur">
  <div class='container'>
  <div class='wrapper'>
    <div class='nav-sub'>
      <p class="title"></p>
      <ul class='switcher nav-list-h'>
        <li><a class="s-comment fas fa-comments fa-fw" target="_self" href='javascript:void(0)'></a></li>
        
          <li><a class="s-toc fas fa-list fa-fw" target="_self" href='javascript:void(0)'></a></li>
        
      </ul>
    </div>
		<div class="nav-main">
      
        
        <a class="title flat-box" target="_self" href='/'>
          
          
          
            CyChan
          
          
        </a>
      

			<div class='menu navigation'>
				<ul class='nav-list-h'>
          
          
          
            
            
              <li>
                <a class="flat-box" href=/
                  
                  
                  
                    id="home"
                  >
                  <i class='fas fa-home fa-fw'></i>首页
                </a>
                
              </li>
            
          
          
            
            
              <li>
                <a class="flat-box" href=/categories/
                  
                  
                  
                    id="categories"
                  >
                  <i class='fas fa-folder-open fa-fw'></i>分类
                </a>
                
              </li>
            
          
          
            
            
              <li>
                <a class="flat-box" href=/tags/
                  
                  
                  
                    id="tags"
                  >
                  <i class='fas fa-tags fa-fw'></i>标签
                </a>
                
              </li>
            
          
          
            
            
              <li>
                <a class="flat-box" href=/archives/
                  
                  
                  
                    id="archives"
                  >
                  <i class='fas fa-archive fa-fw'></i>归档
                </a>
                
              </li>
            
          
          
            
            
              <li>
                <a class="flat-box" href=/friends/
                  
                  
                  
                    id="friends"
                  >
                  <i class='fas fa-link fa-fw'></i>友链
                </a>
                
              </li>
            
          
          
            
            
              <li>
                <a class="flat-box" href=/Message/
                  
                  
                  
                    id="Message"
                  >
                  <i class='fas fa-comments fa-fw fa-fw'></i>留言板
                </a>
                
              </li>
            
          
          
            
            
              <li>
                <a class="flat-box" href=/about/
                  
                  
                  
                    id="about"
                  >
                  <i class='fas fa-info-circle fa-fw'></i>关于
                </a>
                
              </li>
            
          
          
				</ul>
			</div>

      <div class="m_search">
        <form name="searchform" class="form u-search-form">
          <i class="icon fas fa-search fa-fw"></i>
          <input type="text" class="input u-search-input" placeholder="Search..." />
        </form>
      </div>

			<ul class='switcher nav-list-h'>
				
					<li><a class="s-search fas fa-search fa-fw" target="_self" href='javascript:void(0)'></a></li>
				
				<li>
          <a class="s-menu fas fa-bars fa-fw" target="_self" href='javascript:void(0)'></a>
          <ul class="menu-phone list-v navigation white-box">
            
              
            
              <li>
                <a class="flat-box" href=/
                  
                  
                  
                    id="home"
                  >
                  <i class='fas fa-home fa-fw'></i>首页
                </a>
                
              </li>
            
          
            
              
            
              <li>
                <a class="flat-box" href=/categories/
                  
                  
                  
                    id="categories"
                  >
                  <i class='fas fa-folder-open fa-fw'></i>分类
                </a>
                
              </li>
            
          
            
              
            
              <li>
                <a class="flat-box" href=/tags/
                  
                  
                  
                    id="tags"
                  >
                  <i class='fas fa-tags fa-fw'></i>标签
                </a>
                
              </li>
            
          
            
              
            
              <li>
                <a class="flat-box" href=/archives/
                  
                  
                  
                    id="archives"
                  >
                  <i class='fas fa-archive fa-fw'></i>归档
                </a>
                
              </li>
            
          
            
              
            
              <li>
                <a class="flat-box" href=/friends/
                  
                  
                  
                    id="friends"
                  >
                  <i class='fas fa-link fa-fw'></i>友链
                </a>
                
              </li>
            
          
            
              
            
              <li>
                <a class="flat-box" href=/Message/
                  
                  
                  
                    id="Message"
                  >
                  <i class='fas fa-comments fa-fw fa-fw'></i>留言板
                </a>
                
              </li>
            
          
            
              
            
              <li>
                <a class="flat-box" href=/about/
                  
                  
                  
                    id="about"
                  >
                  <i class='fas fa-info-circle fa-fw'></i>关于
                </a>
                
              </li>
            
          
            
          </ul>
        </li>
			</ul>
		</div>
	</div>
  </div>
</header>

<script>setLoadingBarProgress(40);</script>



  <div class="l_body nocover">
    <div class='body-wrapper'>
      

<div class='l_main'>
  

  
    <article id="post" class="post white-box reveal shadow article-type-post" itemscope itemprop="blogPost">
      


  <section class='meta'>
    
      
      
      <div class="meta" id="header-meta">
        
          
  <h1 class="title">
    <a href="/2021/01/31/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E7%AC%94%E8%AE%B0/">
      操作系统笔记
    </a>
  </h1>


        
        <div class='new-meta-box'>
          
            
          
            
              
<div class='new-meta-item author'>
  <a href="https://cychan811.gitee.io" rel="nofollow">
    <img src="https://gitee.com/CyChan811/BlogImage/raw/master/img/头像.jpg">
    <p>CyChan</p>
  </a>
</div>

            
          
            
              
  
  <div class='new-meta-item category'>
    <a href='/categories/%E5%90%8E%E5%8F%B0/' rel="nofollow">
      <i class="fas fa-folder-open fa-fw" aria-hidden="true"></i>
      <p>后台</p>
    </a>
  </div>


            
          
            
              <div class="new-meta-item date">
  <a class='notlink'>
    <i class="fas fa-calendar-alt fa-fw" aria-hidden="true"></i>
    <p>发布于：2021年1月31日</p>
  </a>
</div>

            
          
            
              

            
          
            
              
  <div class="new-meta-item browse valine">
    <a class='notlink'>
      <i class="fas fa-eye fa-fw" aria-hidden="true"></i>
      
      <span id="/2021/01/31/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E7%AC%94%E8%AE%B0/" class="leancloud_visitors" data-flag-title="操作系统笔记">
      <p>
        <span class="leancloud-visitors-count"></span>
      </p>
      </span>
    </a>
  </div>


            
          
        </div>
        
          <hr>
        
      </div>
    
  </section>


      <section class="article typo">
        <div class="article-entry" itemprop="articleBody">
          
          
          <h2 id="1-阻塞-非阻塞IO-同步IO-异步IO，IO多路复用"><a href="#1-阻塞-非阻塞IO-同步IO-异步IO，IO多路复用" class="headerlink" title="1.阻塞/非阻塞IO,同步IO/异步IO，IO多路复用"></a>1.阻塞/非阻塞IO,同步IO/异步IO，IO多路复用</h2><p><strong>1. IO请求的两个阶段：</strong></p>
<ol>
<li>等待资源阶段：IO请求一般需要请求特殊的资源（如磁盘、RAM、文件），当资源被上一个使用者使用没有被释放时，IO请求就会被阻塞，直到能够使用这个资源。</li>
<li>使用资源阶段：真正进行数据接收和发送，即数据在内核空间和数据空间之间的移动。</li>
</ol>
<a id="more"></a>

<p><strong>2. 在等待数据阶段，IO分为阻塞IO和非阻塞IO。（内核空间与外设进行交互过程来区分）</strong></p>
<ol>
<li>阻塞IO： 资源不可用时，IO请求一直阻塞，直到反馈结果（有数据或超时）。</li>
<li>非阻塞IO：资源不可用时，IO请求离开返回，返回数据标识资源不可用。在非阻塞式IO中，用户进程其实是需要不断的主动询问kernel数据准备好了没有。</li>
</ol>
<p><strong>3. 在使用资源阶段，IO分为同步IO和异步IO。（内核空间与用户空间的交互过程来区分）</strong></p>
<ol>
<li>同步IO：应用阻塞在发送或接收数据的状态，直到数据成功传输或返回失败。</li>
<li>异步IO：应用发送或接收数据后立刻返回，数据写入OS缓存，由OS完成数据发送或接收，并返回成功或失败的信息给应用。</li>
</ol>
<p><strong>4. IO多路复用</strong></p>
<ul>
<li>也称为事件驱动IO，如平时用的select/epoll就是IO多路复用</li>
<li><strong>IO多路复用的好处就在于单个进程就可以同时处理多个网络连接的IO</strong></li>
<li>它的基本原理就是select/epoll这个function会不断的轮询所负责的所有socket，当某个socket有数据到达了，就通知用户进程。</li>
</ul>
<p><strong>更多解释→</strong><a href="http://blog.chinaunix.net/uid-28458801-id-4464639.html" target="_blank" rel="noopener">http://blog.chinaunix.net/uid-28458801-id-4464639.html</a></p>
<p><strong>阻塞和非阻塞模式下的read和write操作如下：</strong></p>
<p><img src="https://gitee.com/CyChan811/BlogImage/raw/master/img/20201008174524.png" alt=""></p>
<p><strong>总结：</strong></p>
<ul>
<li>read总是在接收缓存区有数据的时候直接返回，而不是等到应用程序的数据充满才返回。如果此时缓冲区是空的，那么阻塞模式会等待，非阻塞则会返回-1并有EWOULDBLOCK或EAGAIN错误</li>
<li>和read不太一样的是，在阻塞模式下，write只有在发送缓冲区足以容纳应用程序的输出字节时才会返回。在非阻塞的模式下，能写入多少则写入多少，并返回实际写入的字节数</li>
</ul>
<h2 id="2-进程、线程、协程、守护进程"><a href="#2-进程、线程、协程、守护进程" class="headerlink" title="2.进程、线程、协程、守护进程"></a>2.进程、线程、协程、守护进程</h2><h3 id="进程"><a href="#进程" class="headerlink" title="进程"></a>进程</h3><p><strong>程序：</strong> 程序是一些保存在磁盘上的<strong>指令的有序集合</strong>，是静态的。</p>
<p><strong>进程：</strong> 进程是<strong>程序执行的过程</strong>，包括了动态创建、调度和消亡的整个过程，<strong>进程是程序资源管理的最小单位 。</strong></p>
<h3 id="线程"><a href="#线程" class="headerlink" title="线程"></a>线程</h3><p><strong>线程就是我们程序执行的实体。</strong> 线程是<strong>操作系统能够进行运算调度的最小单位</strong>。线程被包含在进程之中，是<strong>进程中的实际运行单位，</strong> 一个进程内可以包含多个线程，<strong>一个进程至少有一个线程（主线程）</strong>，<strong>线程是资源调度的最小单位</strong>。</p>
<h3 id="协程"><a href="#协程" class="headerlink" title="协程"></a>协程</h3><p>协程是一种比线程更加轻量级的微线程。类比一个进程可以拥有多个线程，一个线程也可以拥有多个协程，因此协程又称为微线程。</p>
<h3 id="守护进程"><a href="#守护进程" class="headerlink" title="守护进程"></a>守护进程</h3><p><strong>概述：</strong> 守护进程是脱离于终端并且在后台运行的进程</p>
<ul>
<li>脱离终端是为了避免在执行过程中的信息在终端上显示，并且进程也不会被终端所产生的终端信息所打断。</li>
</ul>
<p><strong>生命周期：</strong> 一般的守护进程的生命周期是从系统启动到系统终止运行，也可以通过杀死进程的方式结束守护进程的生命周期。</p>
<p><strong>例子：</strong> 系统的服务进程</p>
<p><strong>作用：</strong> 周期性执行某任务（只做某种单一的任务）</p>
<h2 id="3-进程状态"><a href="#3-进程状态" class="headerlink" title="3.进程状态"></a>3.进程状态</h2><ol>
<li>新建状态：进程已经创建，但未被OS接纳为可执行进程。（还没有申请到相应的资源）</li>
<li>就绪态： 进程做好了准备，准备执行（只等待处理机）</li>
<li>执行状态：该进程正在执行。</li>
<li>阻塞状态：等待某事件发生才能执行，如等待I/O完成。</li>
<li>终止状态</li>
</ol>
<h2 id="4-进程间通信"><a href="#4-进程间通信" class="headerlink" title="4.进程间通信"></a>4.进程间通信</h2><h4 id="1-管道"><a href="#1-管道" class="headerlink" title="1. 管道"></a>1. 管道</h4><p>管道的功能是将前一个命令的输出，当作另一个命令的输入。可以创建管道的时候创建两个文件描述符，一个作为管道的读端，一个作为管道的写端</p>
<ul>
<li>匿名管道没有实体，是一个伪文件，只能通过fork来复制父进程的fd文件描述符来达到通信的目的，所以它的通信范围是存在父子关系的进程</li>
<li>有名管道，可以在不相关的进程间也能相互通信。因为命令管道，提前创建了一个类型为管道的设备文件，在进程里只要使用这个设备文件，就可以相互通信。</li>
</ul>
<p><strong>管道大小受限，是阻塞的</strong>，必须等其他进程来取才返回，而且是<strong>单向传输的，效率低下，不适合频繁的进程通信。</strong> 管道的优点是实现简单，能够保证我们的数据已经真的被其他进程拿走了。</p>
<h4 id="2-消息队列"><a href="#2-消息队列" class="headerlink" title="2. 消息队列"></a>2. 消息队列</h4><p>消息队列解决了管道阻塞的问题，例如 a 进程要给 b进程发送消息，只需要把消息放在对应的消息队列里就行了，b 进程需要的时候再去对应的消息队列里取出来。<br><strong>但消息队列通信过程中，存在用户态和内核态之间的数据拷贝开销，所以读大数据时很耗时间</strong></p>
<h4 id="3-共享内存"><a href="#3-共享内存" class="headerlink" title="3. 共享内存"></a>3. 共享内存</h4><p>共享内存这个通信方式解决了拷贝所消耗的时间。共享内存的机制是拿出一块虚拟地址空间，映射到相同的物理内存中。这样这个进程写入的东西，另一个进程马上就能看到了。但共享内存又存在多进程竞争资源的问题。</p>
<h4 id="4-信号量"><a href="#4-信号量" class="headerlink" title="4. 信号量"></a>4. 信号量</h4><p>信号量的本质就是一个计数器，用来实现进程之间的互斥与同步，而不是用于缓存进程间通信的数据。</p>
<h4 id="5-信号"><a href="#5-信号" class="headerlink" title="5. 信号"></a>5. 信号</h4><p>上面的进程间通信都是常规状态下的工作模式。对于异常情况下的工作模式，就需要使用“信号”来通知进程了。</p>
<h4 id="6-socket"><a href="#6-socket" class="headerlink" title="6. socket"></a>6. socket</h4><p>前面说到的通信机制，都是工作与一台主机，如果要与不同主机的进程间通信，那么就需要socket通信了。socket同时还可以用于本地主机进程间通信。</p>
<h2 id="5-死锁必要条件、解决死锁策略，写出死锁代码"><a href="#5-死锁必要条件、解决死锁策略，写出死锁代码" class="headerlink" title="5.死锁必要条件、解决死锁策略，写出死锁代码"></a>5.死锁必要条件、解决死锁策略，写出死锁代码</h2><h4 id="必要条件"><a href="#必要条件" class="headerlink" title="必要条件"></a>必要条件</h4><ol>
<li><strong>互斥条件</strong>，要求各个资源互斥，即在一段时间内某资源仅为一个进程所占有。如果这些资源都是可以共享的，那么多个进程直接共享即可，不会存在等待的尴尬场景</li>
<li><strong>非抢占条件</strong>，要求进程所占有的资源使用完后主动释放即可，其他的进程休想抢占这些资源。原因很简单，如果可以抢占，直接拿就好了，不会进入尴尬的等待场景</li>
<li><strong>请求与保持条件：</strong><br>进程已经保持了至少一个资源，但又提出了新的资源请求，而该资源已被其他进程占有，此时请求进程被阻塞，但对自己已获得的资源保持不放。</li>
<li><strong>循环等待条件</strong>，存在一种进程资源的循环等待链，链中每一个进程已获得的资源同时被 链中下一个进程所请求。</li>
</ol>
<h4 id="预防死锁"><a href="#预防死锁" class="headerlink" title="预防死锁"></a>预防死锁</h4><ol>
<li><p>破坏请求条件：一次性分配所有资源，这样就不会再有请求了；</p>
</li>
<li><p>破坏请保持条件：只要有一个资源得不到分配，也不给这个进程分配其他的资源：</p>
</li>
<li><p>破坏不可剥夺条件：当某进程获得了部分资源，但得不到其它资源，则释放已占有的资源；</p>
</li>
<li><p>破坏环路等待条件：系统给每类资源赋予一个编号，每一个进程按编号递增的顺序请求资源，释放则相反。</p>
</li>
</ol>
<h2 id="6-分析静态链接的不足，以及动态链接的特点"><a href="#6-分析静态链接的不足，以及动态链接的特点" class="headerlink" title="6.分析静态链接的不足，以及动态链接的特点"></a>6.分析静态链接的不足，以及动态链接的特点</h2><h5 id="静态库："><a href="#静态库：" class="headerlink" title="静态库："></a>静态库：</h5><p>静态库可以简单的看成一组目标文件的集合，即很多目标文件经过压缩打包后形成的文件。比如在我们日常编程中，如果需要使用printf函数，就需要包stdio.h的库文件，使用strlen时，又需要包string.h的库文件，可是如果直接把对应函数源码编译后形成的.o文件直接提供给我们，将会对我们的管理和使用上造成极大不便，于是可以使用“ar”压缩程序将这些目标文件压缩在一起，形成libx.a静态库文件。<br>注：静态库命名格式：lib + “库名称”+ .a(后缀) 例：libadd.a就是一个叫add的静态库</p>
<ul>
<li>静态链接：<br>对于静态库，程序在编译链接时，将库的代码链接到可执行文件中，程序运行时不再需要静态库。在使用过程中只需要将库和我们的程序编译后的文件链接在一起就可形成一个可执行文件。<ul>
<li>优点：<ol>
<li>发布程序的时候，不需要提供对应的库，因为已经打包到了可执行程序中 </li>
<li>加载库的速度快</li>
</ol>
</li>
<li>缺点：</li>
</ul>
<ol>
<li>内存和磁盘空间浪费：<br>静态链接方式对于计算机内存和磁盘的空间浪费十分严重。假如一个c语言的静态库大小为1MB，系统中有100个需要使用到该库文件，采用静态链接的话，就要浪费进100M的内存，若数量再大，那浪费的也就更多。例如：程序1和程序2都需要用到Lib.o，采用静态链接的话，那么物理内存中就会存放两份对应此文件的拷贝。</li>
<li>更新麻烦：<br>比如一个程序20个模块，每个模块只有1MB，那么每次更新任何一个模块，用户都得重新下载20M的程序。</li>
</ol>
</li>
</ul>
<h5 id="动态库："><a href="#动态库：" class="headerlink" title="动态库："></a>动态库：</h5><p>程序在运行时才去链接动态库的代码，多个程序共享库的代码。一个与动态库链接的可执行文件仅仅包含它用到的函数入口地址的一个表，而不是外部函数所在目标文件的整个机器码。</p>
<ul>
<li>动态链接：<br>由于静态链接具有浪费内存和模块更新困难等问题，提出了动态链接。基本实现思想是把程序按照模块拆分成各个相对独立部分，在程序运行时才将他们链接在一起形成一个完整的程序，而不是像静态链接那样把所有的程序模块都链接成一个单独的可执行文件。所以动态链接是将链接过程推迟到了运行时才进行。<br>同样，假如有程序1，程序2，和Lib.o三个文件，程序1和程序2在执行时都需要用到Lib.o文件，当运行程序1时，系统首先加载程序1，当发现需要Lib.o文件时，也同样加载到内存，再去加载程序2当发现也同样需要用到Lib.o文件时，则不需要重新加载Lib.o，只需要将程序2和Lib.o文件链接起来即可，内存中始终只存在一份Lib.o文件。</li>
<li>优点：<ol>
<li>毋庸置疑的就是节省内存；</li>
<li>减少物理页面的换入换出；</li>
<li>在升级某个模块时，理论上只需要将对应旧的目标文件覆盖掉即可。新版本的目标文件会被自动装载到内存中并且链接起来；</li>
<li>程序在运行时可以动态的选择加载各种程序模块，实现程序的扩展。</li>
</ol>
</li>
<li>缺点：<ol>
<li>发布程序的时候，需要将动态库提供给用户</li>
<li>动态库没有被打包到应用程序中，加载速度相对较慢 （其实速度还是挺快的）</li>
</ol>
</li>
</ul>
<h2 id="7-并行和并发"><a href="#7-并行和并发" class="headerlink" title="7.并行和并发"></a>7.并行和并发</h2><h4 id="并行："><a href="#并行：" class="headerlink" title="并行："></a>并行：</h4><p>指在同一时刻，有多条指令在多个处理器上同时执行。所以无论从微观还是从宏观来看，二者都是一起执行的。</p>
<h4 id="并发："><a href="#并发：" class="headerlink" title="并发："></a>并发：</h4><p>指在同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干段，使多个进程快速交替的执行。</p>
<h2 id="8-互斥锁、自旋锁、读写锁、悲观锁、乐观锁的应用场景"><a href="#8-互斥锁、自旋锁、读写锁、悲观锁、乐观锁的应用场景" class="headerlink" title="8.互斥锁、自旋锁、读写锁、悲观锁、乐观锁的应用场景"></a>8.互斥锁、自旋锁、读写锁、悲观锁、乐观锁的应用场景</h2><h3 id="互斥锁"><a href="#互斥锁" class="headerlink" title="互斥锁"></a>互斥锁</h3><p><strong>被锁住的代码执行时间比较长时</strong>，即上下文切换的时间比代码执行时间短，就应该用互斥锁</p>
<h3 id="自旋锁"><a href="#自旋锁" class="headerlink" title="自旋锁"></a>自旋锁</h3><p><strong>定义：</strong> 当一个线程尝试去获取某一把锁的时候，如果这个锁此时已经被别人获取(占用)，那么此线程就无法获取到这把锁，该线程将会等待，间隔一段时间后会再次尝试获取（利用while循环）。这种采用循环加锁-&gt;等待的机制被称为自旋锁(spinlock)。自旋锁在「用户态」完成加锁和解锁操作，不会主动产生线程上下文切换。</p>
<p><strong>使用场景：</strong> 被锁住的<strong>代码执行时间很短</strong>，即上下文切换的时间比你锁住的代码执行时间还要长，就应该选用互斥锁</p>
<h3 id="读写锁"><a href="#读写锁" class="headerlink" title="读写锁"></a>读写锁</h3><p>读写锁适用于能明确区分读操作和写操作的场景。读写锁在<strong>读多写少</strong>的场景，能发挥出优势。</p>
<h3 id="悲观锁"><a href="#悲观锁" class="headerlink" title="悲观锁"></a>悲观锁</h3><p>悲观锁做事比较悲观，它认为多线程同时修改共享资源的概率比较高，于是很容易出现冲突，所以访问共享资源前，先要上锁。<strong>用于冲突概论比较高的场景</strong></p>
<h3 id="乐观锁"><a href="#乐观锁" class="headerlink" title="乐观锁"></a>乐观锁</h3><p>如果并发访问共享资源时，<strong>冲突概率非常低</strong>的话，就可以使用乐观锁，它的工作方式是，在访问共享资源时，不用先加锁，修改完共享资源后，再验证这段时间内有没有发生冲突，如果没有其他线程在修改资源，那么操作完成，如果发现有其他线程已经修改过这个资源，就放弃本次操作。(版本号机制)</p>
<p>但是，一旦冲突概率上升，就不适合使用乐观锁了，因为它解决冲突的重试成本非常高。</p>
<h2 id="9-分页和分段"><a href="#9-分页和分段" class="headerlink" title="9.分页和分段"></a>9.分页和分段</h2><p><strong>分段机制：</strong> 分段机制就是把虚拟地址空间中的虚拟内存组织成一些长度可变的称为段的内存块单元。段可以用来存放程序的代码、数据和堆栈，或者用来存放系统数据结构。</p>
<p><strong>分页：</strong> 分页就是将这些段，例如代码段分成<strong>均匀的小块</strong>，然后这些给这些小块编号，然后就可以放到内存中去。相应地，内存空间分成若干个物理块，<strong>页和块的大小相等</strong>。可将用户程序的任一页放在内存的任一块中，实现了<strong>离散分配。</strong></p>
<p>内存的分段和分页管理方式和由此衍生的一堆段页式等都属于内存的不连续分配。什么叫不连续分配？就是把程序分割成一块一块的装入内存，在物理上不用彼此相连，在逻辑上使用段表或者页表将离散分布的这些小块串起来形成逻辑上连续的程序。</p>
<p>在基本的分页概念中，我们把程序分成等长的小块。这些小块叫做“页（Page）”，同样内存也被我们分成了和页面同样大小的”页框（Frame）“，一个页可以装到一个页框里。在执行程序的时候我们根据一个页表去查找某个页面在内存的某个页框中，由此完成了逻辑到物理的映射。</p>
<p>分段和分页有很多类似的地方，但是最大的区别在于分页对于用户来说是透明的，分页是为了完成离散存储，所有的页面大小都一样，对程序员来说这就像碎纸机一样，出来的东西没有完整意义。但是分段不一样，分段不定长，<strong>分页由系统完成</strong>，分段有时在编译过程中会指定划分，因此可以保留部分逻辑特征，容易实现分段共享。</p>
<p><strong>区别：</strong></p>
<ol>
<li>分页机制会使用大小固定的内存块，而分段管理则使用了大小可变的块来管理内存。</li>
<li>分页使用固定大小的块更为适合管理物理内存，分段机制使用大小可变的块更适合处理复杂系统的逻辑分区。</li>
<li>段表存储在线性地址空间，而页表则保存在物理地址空间。</li>
</ol>
<h4 id="分页存储的优缺点"><a href="#分页存储的优缺点" class="headerlink" title="分页存储的优缺点"></a>分页存储的优缺点</h4><p>页面是主存物理空间中划分出来的等长的固定区域。</p>
<p><strong>优点</strong>是页长固定，因而便于构造页表、易于管理，且不存在外碎片。</p>
<p><strong>缺点</strong>是页长与程序的逻辑大小不相关，且各页不是程序的独立模块，<strong>不便于实现程序和数据的保护</strong>。</p>
<h4 id="分段存储方式的优缺点"><a href="#分段存储方式的优缺点" class="headerlink" title="分段存储方式的优缺点"></a>分段存储方式的优缺点</h4><p>分页对程序员而言是不可见的，而分段通常对程序员而言是可见的，因而分段为组织程序和数据提供了方便。与页式虚拟存储器相比，段式虚拟存储器有许多优点：</p>
<p><strong>优点：</strong></p>
<ol>
<li>段的逻辑独立性使其易于编译、管理、修改和保护，也便于多道程序共享。</li>
<li>段长可以根据需要动态改变，允许自由调度，以便有效利用主存空间。</li>
<li>方便编程，分段共享，分段保护，动态链接，动态增长</li>
</ol>
<p>因为段的长度不固定，段式虚拟存储器也有一些缺点：</p>
<p><strong>缺点：</strong></p>
<ol>
<li>主存空间分配比较麻烦。</li>
<li>容易在段间留下许多碎片，造成存储空间利用率降低。</li>
<li>由于段长不一定是2的整数次幂，因而不能简单地像分页方式那样用虚拟地址和实存地址的最低若干二进制位作为段内地址，并与段号进行直接拼接，必须用加法操作通过段起址与段内地址的求和运算得到物理地址。因此，段式存储管理比页式存储管理方式需要更多的硬件支持。</li>
</ol>
<h3 id="段页式存储"><a href="#段页式存储" class="headerlink" title="段页式存储"></a>段页式存储</h3><p>段页式存储组织是分段式和分页式结合的存储组织方法，这样可充分利用分段管理和分页管理的优点。</p>
<ol>
<li>用分段方法来分配和管理虚拟存储器。程序的地址空间按逻辑单位分成基本独立的段，而每一段有自己的段名，再把每段分成固定大小的若干页。</li>
<li>用分页方法来分配和管理实存。即把整个主存分成与上述页大小相等的存储块，可装入作业的任何一页。<strong>程序对内存的调入或调出是按页进行的。但它又可按段实现共享和保护。</strong></li>
<li>逻辑地址结构。一个逻辑地址用三个参数表示：段号S；页号P；页内地址d。</li>
<li>段表、页表、段表地址寄存器。为了进行地址转换，系统为每个作业建立一个段表，并且要为该作业段表中的每一个段建立一个页表。系统中有一个段表地址寄存器来指出作业的段表起始地址和段表长度。</li>
</ol>
<p><strong>优点：</strong></p>
<ol>
<li>它提供了大量的虚拟存储空间。</li>
<li>能有效地利用主存，为组织多道程序运行提供了方便。</li>
</ol>
<p><strong>缺点：</strong></p>
<ol>
<li>增加了硬件成本、系统的复杂性和管理上的开消。</li>
<li>存在着系统发生抖动的危险。</li>
<li>存在着内碎片。</li>
<li>还有各种表格要占用主存空间。</li>
</ol>
<p><a href="https://www.cnblogs.com/shenckicc/p/6884921.html" target="_blank" rel="noopener">https://www.cnblogs.com/shenckicc/p/6884921.html</a></p>
<h2 id="10-虚拟内存的作用，分页系统实现虚拟内存原理"><a href="#10-虚拟内存的作用，分页系统实现虚拟内存原理" class="headerlink" title="10.虚拟内存的作用，分页系统实现虚拟内存原理"></a>10.虚拟内存的作用，分页系统实现虚拟内存原理</h2><h4 id="虚拟内存"><a href="#虚拟内存" class="headerlink" title="虚拟内存"></a>虚拟内存</h4><p>虚拟内存是内存管理的一种方式， 它在磁盘上划分出一块空间由操作系统管理，当物理内存耗尽时充当物理内存来使用。它将多个物理内存碎片和部分磁盘空间重定义为连续的地址空间，以此让程序认为自己拥有连续可用的内存。当物理内存不足时，操作系统会将处于不活动状态的程序以及它们的数据全部交换到磁盘上来释放物理内存，以供其它程序使用。</p>
<p>虚拟内存，是指<strong>具有请求调入功能和置换功能，能从逻辑上对内存容量加以扩充的一种存储器系统。其逻辑容量是由内存和外存容量之和所决定</strong>，其运行速度接近于内存速度，而每位的成本却又接近于外存。</p>
<p><strong>作用：</strong></p>
<ol>
<li>它将主存看成是一个存储在磁盘空间上的地址空间的高速缓存，主存中只保存活动区域，并根据需要在磁盘和主存之间来回传送数据。</li>
<li>它为每个进程提供了一致的地址空间,简化了内存管理。</li>
<li>它保护了每个进程的地址空间不被其他进程破坏。（操作系统为每个进程提供一个独立的“页表”）</li>
</ol>
<h2 id="11-页面置换算法的原理"><a href="#11-页面置换算法的原理" class="headerlink" title="11.页面置换算法的原理"></a>11.页面置换算法的原理</h2><p>在进程运行过程中，若要访问的页面不在内存中，而需把它们调入内存，但内存已无空闲空间时，为了保证该进程能够正常运行，系统必须从内存中调出一页程序或数据送到磁盘的对换区中。但应将那个页面调出，须根据一定的算法确定。通常，把选择换出页面的算法称为页面置换算法。</p>
<h4 id="最佳置换算法（理想最好的）"><a href="#最佳置换算法（理想最好的）" class="headerlink" title="最佳置换算法（理想最好的）"></a>最佳置换算法（理想最好的）</h4><p>其选择的被淘汰页面将是以后永不使用的，或许是在<strong>最长（未来）时间内不再被访问的页面。</strong></p>
<h4 id="先进先出-FIFO-页面置换算法（性能最差的）"><a href="#先进先出-FIFO-页面置换算法（性能最差的）" class="headerlink" title="先进先出(FIFO)页面置换算法（性能最差的）"></a>先进先出(FIFO)页面置换算法（性能最差的）</h4><p>该算法总是淘汰最先进入内存的页面，即选择<strong>在内存中驻留时间最久的页面将被淘汰</strong>。该算法实现简单，只需把一个进程已调入内存的页面按先后次序链接成一个队列，并设置一个指针，称为替换指针，是它总是指向最老的页面。</p>
<h4 id="LRU（最近最久未使用）置换算法"><a href="#LRU（最近最久未使用）置换算法" class="headerlink" title="LRU（最近最久未使用）置换算法"></a>LRU（最近最久未使用）置换算法</h4><p>LRU置换算法是选择最近最久未使用的页面予以淘汰。该算法赋予每个页面一个访问字段，用来记录一个页面自上次被访问以来所经历的时间t，当需淘汰一个页面时，选择现有页面中其t值最大的，即最近最久未被使用的页面予以淘汰。</p>
<h4 id="简单的Clock置换算法（LRU的近似算法）"><a href="#简单的Clock置换算法（LRU的近似算法）" class="headerlink" title="简单的Clock置换算法（LRU的近似算法）"></a>简单的Clock置换算法（LRU的近似算法）</h4><p>当利用简单的Clock算法时，只需为每页设置一个访问位，再将内存中的所有页面都通过链接指针链接成一个循环队列。<strong>当某页被访问时，其访问位被置1</strong>。置换算法在选择一页淘汰时，只需检查页的访问位，<strong>如果是0，就选择该页换出；若为1，就重新将它置0，暂不换出，给予该页第二次驻留内存的机会，再按照FIFO算法检查下一个页面</strong>。当检查到队列中的最后一个页面时，若其访问位仍为1，则再返回到队首去检查第一个页面。</p>
<h2 id="12-进程和线程的区别？"><a href="#12-进程和线程的区别？" class="headerlink" title="12.进程和线程的区别？"></a>12.进程和线程的区别？</h2><ol>
<li>进程是资源分配的基本单位，线程是CPU调度的最小单位；</li>
<li>线程依赖于进程而存在，线程是进程的一个实体，一个线程只能属于一个进程，一个进程可以有一个或多个线程。</li>
<li>最本质的区别是：进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其他进程造成影响，而线程只是一个进程中的不同执行路径。线程有自己的栈空间和局部变量，但线程之间没有单独的地址空间，同一类线程共享进程的代码和数据空间，一个线程死掉就等于整个进程死掉。所以还有以下区别：</li>
<li>进程调试简单可靠性高，但创建开销大；线程正好相反，开销小，切换速度快，但是编程调试相对复杂。</li>
<li>通信机制上，因为线程之间互不干扰，相互独立，进程的通信机制相对复杂，需要使用管道、信号、共享内存、套接字等通信机制，而线程由于共享数据段，所以通信机制很方便。</li>
</ol>
<h2 id="13-内核态和用户态"><a href="#13-内核态和用户态" class="headerlink" title="13.内核态和用户态"></a>13.内核态和用户态</h2><h3 id="概念"><a href="#概念" class="headerlink" title="概念"></a>概念</h3><h4 id="内核态："><a href="#内核态：" class="headerlink" title="内核态："></a>内核态：</h4><p><strong>运行操作系统程序，操作硬件</strong>。当一个进程因为系统调用陷入内核代码中执行时处于内核运行态（内核态），此时特权级最高，为0级。</p>
<h4 id="用户态"><a href="#用户态" class="headerlink" title="用户态"></a>用户态</h4><p><strong>运行用户程序</strong>。当一个进程在执行用户自己的代码时处于用户运行态（用户态），此时特权级最低，为3级，是普通的用户进程运行的特权级，大部分用户直接面对的程序都是运行在用户态。</p>
<h3 id="指令划分"><a href="#指令划分" class="headerlink" title="指令划分"></a>指令划分</h3><p><strong>特权指令</strong>：只能由操作系统使用、用户程序不能使用的指令。 举例：启动I/O 内存清零 修改程序状态字 设置时钟 允许/禁止终端 停机</p>
<p><strong>非特权指令</strong>：用户程序可以使用的指令。 举例：控制转移 算数运算 取数指令 <strong>访管指令（使用户程序从用户态陷入内核态</strong>）</p>
<p><strong>特权环</strong>：R0、R1、R2和R3。</p>
<p>R0相当于内核态，R3相当于用户态；</p>
<h3 id="内核态和用户态的区别"><a href="#内核态和用户态的区别" class="headerlink" title="内核态和用户态的区别"></a>内核态和用户态的区别</h3><ul>
<li>处于用户态执行时，进程所能访问的内存空间和对象受到限制，其所处于占有的处理机是可被抢占的 ；</li>
<li>而处于核心态执行中的进程，则能访问所有的内存空间和对象，且所占有的处理机是不允许被抢占的。</li>
</ul>
<h3 id="用户态和内核态的切换"><a href="#用户态和内核态的切换" class="headerlink" title="用户态和内核态的切换"></a>用户态和内核态的切换</h3><ol>
<li>系统调用<ul>
<li>这是用户态进程主动要求切换到内核态的一种方式，用户态进程通过系统调用申请使用操作系统提供的服务程序完成工作。</li>
</ul>
</li>
<li>异常<ul>
<li>当cpu在执行运行在用户态下的程序时，发生了一些没有预知的异常，这时会触发由当前运行进程切换到处理此异常的内核相关进程中，也就是切换到了内核态，如缺页异常。</li>
</ul>
</li>
<li>外围设备的中断<ul>
<li>当外围设备完成用户请求的操作后，会向CPU发出相应的中断信号，这时CPU会暂停执行下一条即将要执行的指令转而去执行与中断信号对应的处理程序，</li>
</ul>
</li>
</ol>
<h2 id="14-Reactor模式和Proactor模式"><a href="#14-Reactor模式和Proactor模式" class="headerlink" title="14.Reactor模式和Proactor模式"></a>14.Reactor模式和Proactor模式</h2><p>以读操作为例（类操作类似）。</p>
<h4 id="在Reactor中实现读："><a href="#在Reactor中实现读：" class="headerlink" title="在Reactor中实现读："></a>在Reactor中实现读：</h4><ul>
<li>注册读就绪事件和相应的事件处理器</li>
<li>事件分离器等待事件</li>
<li>事件到来，激活分离器，分离器调用事件对应的处理器。</li>
<li>事件处理器完成实际的读操作，处理读到的数据，注册新的事件，然后返还控制权。<h4 id="在Proactor中实现读："><a href="#在Proactor中实现读：" class="headerlink" title="在Proactor中实现读："></a>在Proactor中实现读：</h4></li>
<li>处理器发起异步读操作（注意：操作系统必须支持异步IO）。在这种情况下，处理器无视IO就绪事件，它关注的是完成事件。</li>
<li>事件分离器等待操作完成事件</li>
<li>在分离器等待过程中，操作系统利用并行的内核线程执行实际的读操作，并将结果数据存入用户自定义缓冲区，最后通知事件分离器读操作完成。</li>
<li>事件分离器呼唤处理器。</li>
<li>事件处理器处理用户自定义缓冲区中的数据，然后启动一个新的异步操作，并将控制权返回事件分离器。</li>
</ul>
<p><strong>两个模式不同的地方在于，Proactor用于异步IO，而Reactor用于同步IO。</strong></p>
<p><strong>参考</strong>：<a href="http://www.cnblogs.com/dawen/archive/2011/05/18/2050358.html" target="_blank" rel="noopener">http://www.cnblogs.com/dawen/archive/2011/05/18/2050358.html</a></p>
<h4 id="总结："><a href="#总结：" class="headerlink" title="总结："></a>总结：</h4><ul>
<li>Reactor模式，本质就是当IO事件(如读写事件)触发时，通知我们主动去读取，也就是要我们主动将socket接收缓存中的数据读到应用进程内存中。</li>
<li>Proactor模式，我们需要指定一个应用进程内的buffer(内存地址)，交给系统，当有数据包到达时，则写入到这个buffer并通知我们收了多少个字节。</li>
</ul>
<h2 id="15-消息队列的作用？"><a href="#15-消息队列的作用？" class="headerlink" title="15.消息队列的作用？"></a>15.消息队列的作用？</h2><h4 id="解耦"><a href="#解耦" class="headerlink" title="解耦"></a>解耦</h4><h4 id="异步"><a href="#异步" class="headerlink" title="异步"></a>异步</h4><h4 id="削峰"><a href="#削峰" class="headerlink" title="削峰"></a>削峰</h4><h2 id="16-线程越多越好吗"><a href="#16-线程越多越好吗" class="headerlink" title="16.线程越多越好吗"></a>16.线程越多越好吗</h2><p>线程多了，可以提高程序的执行效率，但并不是越多越好。</p>
<ul>
<li>虽然线程本身拥有很少的资源（在iOS中，默认主线程1M，子线程512K），但是<strong>更多的线程意味着更多的内存开销</strong>。创建线程也是需要CPU开销的。</li>
<li>如果线程比核的数量多，则同一时间只能执行与核数量相等的线程数，<strong>线程过多会导致频繁的切换</strong>，消耗过多的CPU时间，降低了程序性能。</li>
<li>使用多线程就可能出现线程安全问题，为了解决线程安全需要使用锁，进而可能会出现死锁问题。<strong>过多的线程会增加程序设计的复杂性</strong>，浪费更多精力去处理多线程通信和数据共享（多线程安全、多线程死锁）。</li>
</ul>
<h2 id="17-创建多少个线程合适呢？"><a href="#17-创建多少个线程合适呢？" class="headerlink" title="17.创建多少个线程合适呢？"></a>17.创建多少个线程合适呢？</h2><h4 id="CPU密集型"><a href="#CPU密集型" class="headerlink" title="CPU密集型"></a>CPU密集型</h4><p>对于CPU密集型计算多线程本质上是提升CPU的使用率，所以对一个4核的CPU来说，理论上创建4个线程就可以了。在多创建只会增加线程切换的开销。所以对于CPU密集型的计算场景<strong>线程数 = CPU核数 + 1</strong></p>
<figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">加1的目的是计算(CPU)密集型的线程恰好在某时因为发生一个页</span><br><span class="line">错误或者因其他原因而暂停，刚好有一个“额外”的线程，可以确</span><br><span class="line">保在这种情况下CPU周期不会中断工作。</span><br></pre></td></tr></table></figure>

<h4 id="I-O密集型"><a href="#I-O密集型" class="headerlink" title="I/O密集型"></a>I/O密集型</h4><p>CPU和I/O的耗时如果是1:1那开2个线程是合适的，如果CPU和I/O的消耗是1:2那么开3个线程是合适的。</p>
<p><img src="https://upload-images.jianshu.io/upload_images/13328095-a4bba3ef4bf1331c.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1142/format/webp" alt=""></p>
<p>如图显示：CPU 在 A、B、C 三个线程之间切换，对于线程 A，当 CPU 从 B、C 切换回来时，线程 A 正好执行完 I/O 操作。这样 CPU 和 I/O 设备的利用率都达到了 100%。</p>
<p>线程等待时间所占比例越高，需要越多线程；线程CPU时间所占比例越高，需要越少线程。<strong>最佳线程数 =CPU 核数 * [ 1 +（I/O 耗时 / CPU 耗时）]</strong></p>
<p>通过APM工具可以可以得到准确的耗时时间。</p>
<h2 id="18-零拷贝"><a href="#18-零拷贝" class="headerlink" title="18.零拷贝"></a>18.零拷贝</h2><h3 id="传统的文件传输"><a href="#传统的文件传输" class="headerlink" title="传统的文件传输"></a>传统的文件传输</h3><p><img src="https://mmbiz.qpic.cn/mmbiz_png/J0g14CUwaZcHKiczImueTBjnrXSnRM13mZLjg2kJB3GQu4AVtqncaSnSV8YVhTMqkxO1Q5ZAWIVY8QkQDwVkW3w/640?wx_fmt=png&tp=webp&wxfrom=5&wx_lazy=1&wx_co=1" alt=""></p>
<p>首先，期间共发生了<strong>4次用户态与内核态的上下文切换</strong>，因为发生了两次系统调用，一次是 <code>read()</code> ，一次是 <code>write()</code>，每次系统调用都得先从用户态切换到内核态，等内核完成任务后，再从内核态切换回用户态。</p>
<p>上下文切换到成本并不小，一次切换需要耗时几十纳秒到几微秒，虽然时间看上去很短，但是在高并发的场景下，这类时间容易被累积和放大，从而影响系统的性能。</p>
<p>其次，还发生了 <strong>4 次数据拷贝</strong>，其中两次是 DMA 的拷贝，另外两次则是通过 CPU 拷贝的，下面说一下这个过程：</p>
<ul>
<li><strong>第一次拷贝</strong>，把磁盘上的数据拷贝到操作系统内核的缓冲区里，这个拷贝的过程是通过 DMA 搬运的。</li>
<li><strong>第二次拷贝</strong>，把内核缓冲区的数据拷贝到用户的缓冲区里，于是我们应用程序就可以使用这部分数据了，这个拷贝到过程是由 CPU 完成的。</li>
<li><strong>第三次拷贝</strong>，把刚才拷贝到用户的缓冲区里的数据，再拷贝到内核的 socket 的缓冲区里，这个过程依然还是由 CPU 搬运的。</li>
<li><strong>第四次拷贝</strong>，把内核的 socket 缓冲区里的数据，拷贝到网卡的缓冲区里，这个过程又是由 DMA 搬运的。</li>
</ul>
<p>要想提高文件传输的性能，就需要减少 <strong>「用户态与内核态的上下文切换」和「内存拷贝」的次数。</strong></p>
<h4 id="零拷贝具体方法：https-mp-weixin-qq-com-s-P0IP6c-qFhuebwdwD8HM7w"><a href="#零拷贝具体方法：https-mp-weixin-qq-com-s-P0IP6c-qFhuebwdwD8HM7w" class="headerlink" title="零拷贝具体方法：https://mp.weixin.qq.com/s/P0IP6c_qFhuebwdwD8HM7w"></a>零拷贝具体方法：<a href="https://mp.weixin.qq.com/s/P0IP6c_qFhuebwdwD8HM7w" target="_blank" rel="noopener">https://mp.weixin.qq.com/s/P0IP6c_qFhuebwdwD8HM7w</a></h4><h2 id="19-线程安全"><a href="#19-线程安全" class="headerlink" title="19.线程安全"></a>19.线程安全</h2><h3 id="什么是线程安全"><a href="#什么是线程安全" class="headerlink" title="什么是线程安全"></a>什么是线程安全</h3><p>多个线程访问同一个对象时，不管你通过怎样的调用方式或者说这些线程如何交替的执行，都不需要进行额外的同步，或者在调用方进行任何其他操作，调用这个对象的行为都可以获得正确的结果，那么这个对象就是线程安全的。</p>
<h3 id="多线程编程中的三个核心概念"><a href="#多线程编程中的三个核心概念" class="headerlink" title="多线程编程中的三个核心概念"></a>多线程编程中的三个核心概念</h3><h4 id="原子性"><a href="#原子性" class="headerlink" title="原子性"></a>原子性</h4><p>这一点，跟数据库事务的原子性概念差不多，即一个操作（有可能包含有多个子操作）要么全部执行（生效），要么全部都不执行（都不生效）。</p>
<p><strong>通过锁和同步可以保证原子性</strong></p>
<h4 id="可见性"><a href="#可见性" class="headerlink" title="可见性"></a>可见性</h4><p>可见性是指，当多个线程并发访问共享变量时，一个线程对共享变量的修改，其它线程能够立即看到。缓存更新不及时可能会导致这个问题）</p>
<p><strong>通过<code>volatile</code>关键字可以保证可见性</strong></p>
<h4 id="顺序性"><a href="#顺序性" class="headerlink" title="顺序性"></a>顺序性</h4><p>顺序性指的是，程序执行的顺序按照代码的先后顺序执行。</p>
<p>处理器为了提高程序整体的执行效率，可能会对代码进行优化，其中的一项优化方式就是调整代码顺序，按照更高效的顺序执行代码。</p>
<p><strong>可通过volatile在一定程度上保证顺序性，另外还可以通过synchronized和锁来保证顺序性。synchronized和锁保证顺序性的原理和保证原子性一样，都是通过保证同一时间只会有一个线程执行目标代码段来实现的。</strong></p>
<h2 id="20-硬链接与软链接的区别"><a href="#20-硬链接与软链接的区别" class="headerlink" title="20.硬链接与软链接的区别"></a>20.硬链接与软链接的区别</h2><h3 id="概念："><a href="#概念：" class="headerlink" title="概念："></a>概念：</h3><p><strong>硬链接（相当于别名）：</strong> A是B的硬链接（A和B都是文件名），则<strong>A的目录项中的inode节点号与B的目录项中的inode节点号相同</strong>，即一个inode节点对应两个不同的文件名，<strong>两个文件名指向同一个文件</strong>，A和B对文件系统来说是完全平等的。如果删除了其中一个，对另外一个没有影响。每增加一个文件名，inode节点上的链接数增加一，每删除一个对应的文件名，inode节点上的链接数减一，直到为0，inode节点和对应的数据块被回收。</p>
<p><strong>软连接（相当于快捷方式）：</strong> A是B的软链接（A和B都是文件名），<strong>A的目录项中的inode节点号与B的目录项中的inode节点号不相同</strong>，A和B指向的是两个不同的inode，继而<strong>指向两块不同的数据块</strong>。但是A的数据块中存放的只是B的路径名（可以根据这个找到B的目录项）。A和B之间是“主从”关系，如果B被删除了，A仍然存在（因为两个是不同的文件），但指向的是一个无效的链接。</p>
<h3 id="区别："><a href="#区别：" class="headerlink" title="区别："></a>区别：</h3><p><strong>硬链接：</strong></p>
<ol>
<li>不能对目录创建硬链接，原因是文件系统不能存在链接环，存在环的后果是会导致例如文件遍历等操作的混乱；</li>
<li>不能对不同的文件系统创建硬链接，即两个文件名要在相同的文件系统下；</li>
<li>不能对不存在的文件创建硬链接</li>
</ol>
<p><strong>软连接：</strong></p>
<ol>
<li>可以对目录创建软链接，遍历操作会忽略目录的软链接（软连接是文件，虽然它指向目录项，但不会把它当成目录处理）；</li>
<li>可以跨文件系统；</li>
<li>可以对不存在的文件创建软链接，因为放的只是一个字符串，至于这个字符串是不是对于一个实际的文件，就是另外一回事了。</li>
</ol>
<h2 id="21-僵尸进程与孤儿进程的区别"><a href="#21-僵尸进程与孤儿进程的区别" class="headerlink" title="21.僵尸进程与孤儿进程的区别"></a>21.僵尸进程与孤儿进程的区别</h2><p><strong>孤儿进程：</strong> 父进程结束了，而它的一个或多个子进程还在运行，那么这些子进程就成为孤儿进程。子进程的资源由init进程(进程号PID = 1)回收。</p>
<p><strong>僵尸进程：</strong> 子进程退出了，但是父进程还活着，父进程不去释放子进程的pcb（进程控制块），孩子就变成了僵尸进程</p>
<h2 id="22-poll，epoll和select的优缺点"><a href="#22-poll，epoll和select的优缺点" class="headerlink" title="22.poll，epoll和select的优缺点"></a>22.poll，epoll和select的优缺点</h2><h4 id="select"><a href="#select" class="headerlink" title="select"></a>select</h4><ol>
<li>每次调用select，都需要把fd集合从用户态拷贝到内核态，这个开销在fd很多时会很大</li>
<li>同时每次调用select都需要在内核遍历传递进来的所有fd，这个开销在fd很多时也很大</li>
<li>select支持的文件描述符数量太小了，默认是1024</li>
</ol>
<h4 id="poll"><a href="#poll" class="headerlink" title="poll"></a>poll</h4><p>poll的实现和select非常相似，只是描述fd集合的方式不同，poll使用pollfd结构而不是select的fd_set结构，其他的都差不多。<br>select，poll实现需要自己不断轮询所有fd集合，直到设备就绪，期间可能要睡眠和唤醒多次交替。<strong>但它没有最大连接数的限制，原因是它是基于链表来存储的。</strong></p>
<h4 id="epoll"><a href="#epoll" class="headerlink" title="epoll"></a>epoll</h4><p>对于第一个缺点，epoll的解决方案在epoll_ctl函数中。每次注册新的事件到epoll句柄中时（在epoll_ctl中指定EPOLL_CTL_ADD），会把所有的<strong>fd拷贝进内核</strong>，而不是在epoll_wait的时候重复拷贝。epoll保证了<strong>每个fd在整个过程中只会拷贝一次。</strong></p>
<p>对于第二个缺点，epoll的解决方案不像select或poll一样每次都把current轮流加入fd对应的设备等待队列中，而只在epoll_ctl时把current挂一遍（这一遍必不可少）并为每个fd指定一个回调函数，当设备就绪，唤醒等待队列上的等待者时，就会调用这个回调函数，而这个回调函数会把就绪的fd加入一个就绪链表）。<strong>epoll_wait的工作实际上就是在这个就绪链表中查看有没有就绪的fd</strong>（利用schedule_timeout()实现睡一会，判断一会的效果）</p>
<p>对于第三个缺点，<strong>epoll没有这个限制</strong>，它所支持的FD上限是最大可以打开文件的数目，这个数字一般远大于2048，主要和系统内存有关。epoll底层使用红黑树实现的。</p>
<h2 id="23-物理内存、虚拟内存的区别、虚拟地址空间概念及区别"><a href="#23-物理内存、虚拟内存的区别、虚拟地址空间概念及区别" class="headerlink" title="23.物理内存、虚拟内存的区别、虚拟地址空间概念及区别"></a>23.物理内存、虚拟内存的区别、虚拟地址空间概念及区别</h2><p><strong>物理内存（内存条）</strong>：当打开程序时，系统会将这些程序加载到物理内存上。</p>
<p><strong>虚拟内存（硬盘）</strong>：虚拟的不是物理内存，而是代替物理内存行使存储的功能，物理内存的运行程序的功能是无法用虚拟内存来完成的。</p>
<p><strong>物理内存与虚拟内存的关系</strong>：当运行程序过多，物理内存不够用时，系统会将一部分硬盘空间当内存使用，这部分空间就是虚拟内存。</p>
<p><strong>虚拟地址空间（作用：解决物理内存稀缺问题）</strong>：系统为每个进程所分配的4GB虚拟地址空间（32位系统），用来存放进程的虚拟地址，再通过MMU（内存管理单元）将虚拟地址映射到物理内存地址。</p>
<p>每个进程创建加载的时候，会被分配一个大小为4G的连续的虚拟地址空间，虚拟的意思就是，其实这个地址空间时不存在的，仅仅是每个进程“认为”自己拥有4G的内存，而实际上，它用了多少空间，操作系统就在物理内存上划出多少空间给它，等到进程真正运行的时候，需要某些数据并且数据不在物理内存中，才会触发缺页异常，进行数据拷贝</p>
<p>虚拟地址空间中进行空间划分的作用：<strong>保护数据和将数据分类</strong></p>
<h2 id="24-虚拟地址空间划分"><a href="#24-虚拟地址空间划分" class="headerlink" title="24.虚拟地址空间划分"></a>24.虚拟地址空间划分</h2><p><img src="https://img-blog.csdnimg.cn/2019031221492982.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzODgzMDg1,size_16,color_FFFFFF,t_70" alt=""></p>
<h4 id="1-保留区（受保护的地址）"><a href="#1-保留区（受保护的地址）" class="headerlink" title="1. 保留区（受保护的地址）"></a>1. 保留区（受保护的地址）</h4><p>保留区即为受保护的地址，大小为0~4K，位于虚拟地址空间的最低部分，未赋予物理地址（不会与内存地址相对应，因此其不会放任何内容）。任何对它的引用都是非法的，用于捕捉使用空指针和小整型值指针引用内存的异常情况。大多数操作系统中，极小的地址通常都是不允许访问的，如NULL。</p>
<h4 id="2-代码段"><a href="#2-代码段" class="headerlink" title="2. 代码段"></a>2. 代码段</h4><p>代码段也称正文段或文本段，通常用于存放程序执行代码(即CPU执行的机器指令)。一般C语言执行语句都编译成机器代码保存在代码段。通常代码段是可共享的，因此频繁执行的程序只需要在内存中拥有一份拷贝即可。代码段通常属于只读，以防止其他程序意外地修改其指令(对该段的写操作将导致段错误)。某些架构也允许代码段为可写，即允许修改程序。  </p>
<h4 id="3-数据段（-data段）"><a href="#3-数据段（-data段）" class="headerlink" title="3.数据段（.data段）"></a>3.数据段（.data段）</h4><p>.data存放初始化了的且初始化的值不为0的全局变量</p>
<h4 id="4-bss段"><a href="#4-bss段" class="headerlink" title="4. .bss段"></a>4. .bss段</h4><p>存放未初始化及初始化为0的全局变量</p>
<p>打印未初始化的全局变量会看到值为0，因为存放于.bss段，操作系统会将.bss段的数据全部赋值为0</p>
<h4 id="5-堆空间-heap"><a href="#5-堆空间-heap" class="headerlink" title="5. 堆空间(heap)"></a>5. 堆空间(heap)</h4><p>在《深入理解计算机系统》中的名称是运行时堆（由malloc创建），也就是说这里的堆空间是暂时没有的，当程序运行，new或malloc之后才会分配堆内存，由<strong>低地址向高地址增长</strong>。堆中内容是匿名的，不能按名字直接访问，只能通过指针间接访问。</p>
<h4 id="6-内存映射段（共享库）"><a href="#6-内存映射段（共享库）" class="headerlink" title="6. 内存映射段（共享库）"></a>6. 内存映射段（共享库）</h4><p>也就是动态链接库，Windows下是<em>.dll,Linux下是</em>so</p>
<h4 id="7-栈空间-stack"><a href="#7-栈空间-stack" class="headerlink" title="7. 栈空间(stack)"></a>7. 栈空间(stack)</h4><p>用于存放局部变量（非静态局部变量，C语言称为自动变量），分配存储空间时<strong>从上往下</strong>。栈和堆都是后进先出的数据结构。</p>
<h4 id="8-命令行参数"><a href="#8-命令行参数" class="headerlink" title="8. 命令行参数"></a>8. 命令行参数</h4><p>该段用于存放命令行参数的内容：argc和argv。</p>
<h4 id="9-环境变量"><a href="#9-环境变量" class="headerlink" title="9. 环境变量"></a>9. 环境变量</h4><p>用于存放当前的环境变量，在Linux中用env命令可以查看其值。</p>
<h3 id="虚拟地址空间的好处"><a href="#虚拟地址空间的好处" class="headerlink" title="虚拟地址空间的好处"></a>虚拟地址空间的好处</h3><ol>
<li>方便编译器和操作系统安排程序的地址；</li>
<li>方便实现各个进程空间之间的隔离，互不干扰，因为每个进程都对应自己的虚拟地址空间；</li>
<li>实现虚拟存储，从逻辑上扩大了内存。</li>
</ol>
<h2 id="25-内核接受网络数据全过程"><a href="#25-内核接受网络数据全过程" class="headerlink" title="25.内核接受网络数据全过程"></a>25.内核接受网络数据全过程</h2><p><img src="https://img-blog.csdnimg.cn/20191025213749309.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FybWxpbnV4d3c=,size_16,color_FFFFFF,t_70" alt=""></p>
<p>如上图所示，进程在 Recv 阻塞期间：</p>
<ul>
<li>计算机收到了对端传送的数据(步骤 ①)</li>
<li>数据经由网卡传送到内存(步骤 ②)</li>
<li>然后网卡通过中断信号通知 CPU 有数据到达，CPU 执行中断程序(步骤 ③)</li>
<li>此处的中断程序主要有两项功能，先将网络数据写入到对应 Socket 的接收缓冲区里面(步骤 ④)，再唤醒进程 A(步骤 ⑤)，重新将进程 A 放入内核的工作队列中。</li>
</ul>
<p><strong>详细：</strong> <a href="https://zhuanlan.zhihu.com/p/63179839" target="_blank" rel="noopener">https://zhuanlan.zhihu.com/p/63179839</a></p>
<h2 id="26-epoll实现过程"><a href="#26-epoll实现过程" class="headerlink" title="26.epoll实现过程"></a>26.epoll实现过程</h2><ol>
<li>内核帮我们在epoll文件系统里建了个file结点，并在内核cache里建了个红黑树用于存储以后epoll_ctl传来的socket外，还会再建立一个rdllist双向链表，用于存储准备就绪的事件</li>
<li>把要监听的socket放到对应的红黑树上，所有添加到epoll中的事件都会与设备(如网卡)驱动程序建立回调关系，也就是说相应事件的发生时会调用这里的回调方法。它会把这样的事件放到上面的rdllist双向链表中，即就绪列表。</li>
<li>判断就绪列表是否为空，如果rdllist链表不为空，则将这里的事件复制到用户态内存（使用共享内存提高效率）中，同时将事件数量返回给用户。最后清空就绪列表。</li>
<li>如果监听的事件是LT模式，它发现soket上还有未处理的事件，则在清理就绪列表后，重新把该socket放回刚刚清空的就绪列表。</li>
</ol>
<h2 id="27-epoll模型水平触发、边沿触发优缺点对比"><a href="#27-epoll模型水平触发、边沿触发优缺点对比" class="headerlink" title="27.epoll模型水平触发、边沿触发优缺点对比"></a>27.epoll模型水平触发、边沿触发优缺点对比</h2><h4 id="水平触发优、缺点"><a href="#水平触发优、缺点" class="headerlink" title="水平触发优、缺点"></a>水平触发优、缺点</h4><ul>
<li><strong>优点：</strong> 当进行socket通信的时候，保证了数据的完整输出，进行IO操作的时候，如果还有数据，就会一直的通知你。</li>
<li><strong>缺点：</strong> 由于只要还有数据，内核就会不停的从内核空间转到用户空间，所有占用了大量内核资源，试想一下当有大量数据到来的时候，每次读取一个字节，这样就会不停的进行切换。内核资源的浪费严重。效率来讲也是很低的。</li>
</ul>
<h4 id="边沿触发优、缺点及应用场景"><a href="#边沿触发优、缺点及应用场景" class="headerlink" title="边沿触发优、缺点及应用场景"></a>边沿触发优、缺点及应用场景</h4><ul>
<li><strong>优点：</strong> 每次内核只会通知一次，大大减少了内核资源的浪费，提高效率。</li>
<li><strong>缺点：</strong> 不能保证数据的完整。不能及时的取出所有的数据。</li>
<li><strong>应用场景：</strong> 处理大数据。使用non-block模式的socket。</li>
</ul>
<h2 id="28-使用Linux-epoll模型，水平触发模式；当socket可写时，会不停的触发socket可写的事件，如何处理？"><a href="#28-使用Linux-epoll模型，水平触发模式；当socket可写时，会不停的触发socket可写的事件，如何处理？" class="headerlink" title="28.使用Linux epoll模型，水平触发模式；当socket可写时，会不停的触发socket可写的事件，如何处理？"></a>28.使用Linux epoll模型，水平触发模式；当socket可写时，会不停的触发socket可写的事件，如何处理？</h2><h4 id="第一种最普遍的方式："><a href="#第一种最普遍的方式：" class="headerlink" title="第一种最普遍的方式："></a>第一种最普遍的方式：</h4><p>需要向socket写数据的时候才把socket加入epoll，等待可写事件。<br>接受到可写事件后，调用write或者send发送数据。<br>当所有数据都写完后，把socket移出epoll。</p>
<p>这种方式的缺点是，即使发送很少的数据，也要把socket加入epoll，写完后在移出epoll，有一定操作代价。</p>
<h4 id="一种改进的方式："><a href="#一种改进的方式：" class="headerlink" title="一种改进的方式："></a>一种改进的方式：</h4><p>开始不把socket加入epoll，需要向socket写数据的时候，直接调用write或者send发送数据。如果返回EAGAIN，则说明数据较大，把socket加入epoll，在epoll的驱动下写数据，全部数据发送完毕后，再移出epoll。</p>
<p>这种方式的优点是：数据不多的时候可以避免epoll的事件处理，提高效率。</p>
<h2 id="29-惊群效应"><a href="#29-惊群效应" class="headerlink" title="29.惊群效应"></a>29.惊群效应</h2><p>惊群效应（thundering herd）是指多进程（多线程）在同时阻塞等待同一个事件的时候（休眠状态），如果等待的这个事件发生，那么他就会唤醒等待的所有进程（或者线程），但是最终却只能有一个进程（线程）获得这个时间的“控制权”，对该事件进行处理，而其他进程（线程）获取“控制权”失败，只能重新进入休眠状态，这种现象和性能浪费就叫做惊群效应。</p>
<p><strong>更多：</strong> <a href="https://zhuanlan.zhihu.com/p/51251700" target="_blank" rel="noopener">滴滴云：Linux惊群效应之Nginx解决方案</a></p>
<h2 id="30-Linux每一个运行的程序（进程）操作系统都会在内存中为其分配一个0-4G的地址空间（虚拟地址空间）。cpu为什么要使用虚拟地址空间与物理地址空间映射？解决了什么样的问题"><a href="#30-Linux每一个运行的程序（进程）操作系统都会在内存中为其分配一个0-4G的地址空间（虚拟地址空间）。cpu为什么要使用虚拟地址空间与物理地址空间映射？解决了什么样的问题" class="headerlink" title="30.Linux每一个运行的程序（进程）操作系统都会在内存中为其分配一个0~4G的地址空间（虚拟地址空间）。cpu为什么要使用虚拟地址空间与物理地址空间映射？解决了什么样的问题"></a>30.Linux每一个运行的程序（进程）操作系统都会在内存中为其分配一个0~4G的地址空间（虚拟地址空间）。cpu为什么要使用虚拟地址空间与物理地址空间映射？解决了什么样的问题</h2><ol>
<li>方便编译器和操作系统安排程序的地址分布。<br>程序可以使用一系列相邻的虚拟地址来访问物理内存中不相邻的大内存缓冲区</li>
<li>方便进程之间隔离<br>不同进程使用的虚拟地址彼此隔离。一个进程中的代码无法更改正在由另一个进程使用的物理内存</li>
<li>方便OS使用你那可怜的内存<br>程序可以使用一系列虚拟内存地址来访问可用物理内存的内存缓冲区。当物理内存的供应量变小时，内存管理会将物理内存页（通常大小为4KB）保存到磁盘文件。数据或代码页会根据需要在物理内存与磁盘之间移动。</li>
</ol>
<h2 id="31-查看端口被占用的命令"><a href="#31-查看端口被占用的命令" class="headerlink" title="31.查看端口被占用的命令"></a>31.查看端口被占用的命令</h2><p>Linux 查看端口占用情况可以使用 lsof 和 netstat 命令。</p>
<h3 id="lsof"><a href="#lsof" class="headerlink" title="lsof"></a>lsof</h3><p>lsof(list open files)是一个列出当前系统打开文件的工具。</p>
<p>lsof 查看端口占用语法格式：<br><code>lsof -i:端口号</code></p>
<h3 id="netstat"><a href="#netstat" class="headerlink" title="netstat"></a>netstat</h3><p><code>netstat -tunlp | grep 端口号</code><br>用于显示 tcp，udp 的端口和进程等相关情况。</p>
<h2 id="32-Linux常用的排查cpu、io、网络、内存常用的工具"><a href="#32-Linux常用的排查cpu、io、网络、内存常用的工具" class="headerlink" title="32.Linux常用的排查cpu、io、网络、内存常用的工具"></a>32.Linux常用的排查cpu、io、网络、内存常用的工具</h2><p><a href="https://www.jianshu.com/p/0bbac570fa4c" target="_blank" rel="noopener">https://www.jianshu.com/p/0bbac570fa4c</a></p>
<h1 id="问题"><a href="#问题" class="headerlink" title="问题"></a>问题</h1><h2 id="1-自旋锁通常会出现哪些问题"><a href="#1-自旋锁通常会出现哪些问题" class="headerlink" title="1. 自旋锁通常会出现哪些问题?"></a>1. 自旋锁通常会出现哪些问题?</h2><p>如果某个线程拿着锁死不放手，其他线程没法拿到这把锁，只好等待获取锁的线程进入循环等待的状态，等待不是睡觉，还是会消耗CPU，等待久了就会导致CPU的使用率太高。</p>
<h2 id="2-自旋锁和其他锁有什么不同？"><a href="#2-自旋锁和其他锁有什么不同？" class="headerlink" title="2. 自旋锁和其他锁有什么不同？"></a>2. 自旋锁和其他锁有什么不同？</h2><p>从<strong>线程状态</strong> 来看，自旋锁的状态是运行-运行-运行。而非自旋锁的状态是运行—阻塞—运行，所以自旋锁会更高效。</p>
<p>不管是什么锁，都是为了实现<strong>保护共享资源</strong>而提出的一种锁机制，都是为了对某项资源的互斥使用。对于<strong>互斥锁</strong>而言，如果资源已经被占用，那么资源的申请者只会进入<strong>睡眠的状态</strong>。而<strong>自旋锁</strong>不会引起调用者睡眠，而是<strong>一直循环</strong>在那里查看该自旋锁的保持着是否已经释放了锁。</p>
<p>在多处理器环境中对<strong>持有锁时间较短的程序</strong>来说使用自旋锁代替一般的互斥锁往往能提高程序的性能。</p>
<h2 id="3-自旋锁有哪些优点？"><a href="#3-自旋锁有哪些优点？" class="headerlink" title="3. 自旋锁有哪些优点？"></a>3. 自旋锁有哪些优点？</h2><ol>
<li>因为运行在用户态，没有上下文的线程状态切换，线程一直处于active，减少了不必要的上下文切换，从而执行速度较快</li>
<li>因为非自旋锁在没有获取锁的情况下会进入阻塞状态，从而进入内核态，此时就需要线程的上下文切换，因为阻塞后进入内核调度状态，会导致用户态和内核态之间的切换，影响锁的性能。</li>
</ol>
<h2 id="4-多线程不加锁出现数据紊乱的例子"><a href="#4-多线程不加锁出现数据紊乱的例子" class="headerlink" title="4. 多线程不加锁出现数据紊乱的例子"></a>4. 多线程不加锁出现数据紊乱的例子</h2><p>最典型的是：<br>工作线程用来生产产品，生产完成之后，将产品计数加1</p>
<figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br></pre></td><td class="code"><pre><span class="line">int prducts_counts&#x3D;0;</span><br><span class="line">void ProduceThreadFunc()&#123;</span><br><span class="line">    &#x2F;&#x2F;生产产品</span><br><span class="line">    products_counts++;</span><br><span class="line">&#125;</span><br><span class="line">如果使用多线程不同步的话，可能会出现如下过程：</span><br><span class="line">prducts_counts值为0</span><br><span class="line">线程A生产了一个产品</span><br><span class="line">线程A将products_counts变量读入寄存器</span><br><span class="line">线程A将这个变量在寄存器中执行++运算（得到的是1）</span><br><span class="line">线程A时间片到交出CPU</span><br><span class="line">线程B获得CPU时间</span><br><span class="line">线程B生产了一个产品</span><br><span class="line">线程B将products_counts变量读入寄存器（0）</span><br><span class="line">线程B将这个变量在寄存器中执行++运算（得到的是1）</span><br><span class="line">线程B将寄存器内容写回内存</span><br><span class="line">products_counts值为1</span><br><span class="line">线程B时间片到，交出CPU</span><br><span class="line">线程A继续执行</span><br><span class="line">线程A将之前计算的值（1）再次写入内存</span><br><span class="line">products_counts值为1</span><br><span class="line"></span><br><span class="line">这种情况下生产了两个产品结果却是1</span><br><span class="line">这还是在单核心的情况下</span><br><span class="line">如果是多核心，执行过程更加混乱</span><br></pre></td></tr></table></figure>

<h4 id="—————————————-如有错误，欢迎指正！—————————————"><a href="#—————————————-如有错误，欢迎指正！—————————————" class="headerlink" title="—————————————-如有错误，欢迎指正！—————————————-"></a>—————————————-如有错误，欢迎指正！—————————————-</h4>
          
            <div class='article_footer'>
              
                
  
    
    



  

  
    
    



  

  
    
    

<section class="widget copyright  desktop mobile">
  <div class='content'>
    
      <blockquote>
        
          
            <p>本文由CyChan创作，转载请注明出处</p>

          
        
          
            <p>博客内容遵循 署名-非商业性使用-相同方式共享 4.0 国际 (CC BY-NC-SA 4.0) 协议</p>

          
        
          
            <p>本文永久链接是：<a href=https://cychan811.gitee.io/2021/01/31/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E7%AC%94%E8%AE%B0/>https://cychan811.gitee.io/2021/01/31/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E7%AC%94%E8%AE%B0/</a></p>
          
        
      </blockquote>
    
  </div>
</section>

  

  
    
    

<section class="widget qrcode  desktop mobile">
  

  <div class='content article-entry'>
    
      
        <div class='fancybox'><img src='https://gitee.com/CyChan811/BlogImage/raw/master/img/20200704103702.png'
        
          height='128px'
        ></div>
      
    
  </div>
</section>

  


              
            </div>
          
        </div>
        
          


  <section class='meta' id="footer-meta">
    <div class='new-meta-box'>
      
        
          <div class="new-meta-item date" itemprop="dateUpdated" datetime="2021-01-31T17:32:24+08:00">
  <a class='notlink'>
    <i class="fas fa-edit fa-fw" aria-hidden="true"></i>
    <p>更新于：2021年1月31日</p>
  </a>
</div>

        
      
        
          
  
  <div class="new-meta-item meta-tags"><a class="tag" href="/tags/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/" rel="nofollow"><i class="fas fa-hashtag fa-fw" aria-hidden="true"></i><p>操作系统</p></a></div>


        
      
        
          

        
      
        
          
  <div class="new-meta-item share -mob-share-list">
  <div class="-mob-share-list share-body">
    
      
        <a class="-mob-share-qq" title="" rel="external nofollow noopener noreferrer"
          
          href="http://connect.qq.com/widget/shareqq/index.html?url=https://cychan811.gitee.io/2021/01/31/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E7%AC%94%E8%AE%B0/&title=操作系统笔记 - CyChan's Blog&summary=1.阻塞/非阻塞IO,同步IO/异步IO，IO多路复用1. IO请求的两个阶段：

等待资源阶段：IO请求一般需要请求特殊的资源（如磁盘、RAM、文件），当资源被上一个使用者使用没有被释放时，IO请求就会被阻塞，直到能够使用这个资源。
使用资源阶段：真正进行数据接收和发送，即数据在内核空间和数据空间之间的移动。
"
          
          >
          
            <img src="https://cdn.jsdelivr.net/gh/xaoxuu/cdn-assets/logo/128/qq.png">
          
        </a>
      
    
      
        <a class="-mob-share-qzone" title="" rel="external nofollow noopener noreferrer"
          
          href="https://sns.qzone.qq.com/cgi-bin/qzshare/cgi_qzshare_onekey?url=https://cychan811.gitee.io/2021/01/31/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E7%AC%94%E8%AE%B0/&title=操作系统笔记 - CyChan's Blog&summary=1.阻塞/非阻塞IO,同步IO/异步IO，IO多路复用1. IO请求的两个阶段：

等待资源阶段：IO请求一般需要请求特殊的资源（如磁盘、RAM、文件），当资源被上一个使用者使用没有被释放时，IO请求就会被阻塞，直到能够使用这个资源。
使用资源阶段：真正进行数据接收和发送，即数据在内核空间和数据空间之间的移动。
"
          
          >
          
            <img src="https://cdn.jsdelivr.net/gh/xaoxuu/cdn-assets/logo/128/qzone.png">
          
        </a>
      
    
      
        <a class="-mob-share-weibo" title="" rel="external nofollow noopener noreferrer"
          
          href="http://service.weibo.com/share/share.php?url=https://cychan811.gitee.io/2021/01/31/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E7%AC%94%E8%AE%B0/&title=操作系统笔记 - CyChan's Blog&summary=1.阻塞/非阻塞IO,同步IO/异步IO，IO多路复用1. IO请求的两个阶段：

等待资源阶段：IO请求一般需要请求特殊的资源（如磁盘、RAM、文件），当资源被上一个使用者使用没有被释放时，IO请求就会被阻塞，直到能够使用这个资源。
使用资源阶段：真正进行数据接收和发送，即数据在内核空间和数据空间之间的移动。
"
          
          >
          
            <img src="https://cdn.jsdelivr.net/gh/xaoxuu/cdn-assets/logo/128/weibo.png">
          
        </a>
      
    
  </div>
</div>



        
      
    </div>
  </section>


        
        
          <div class="prev-next">
            
              <a class='prev' href='/2021/01/31/%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%BD%91%E7%BB%9C%E7%AC%94%E8%AE%B0/'>
                <p class='title'><i class="fas fa-chevron-left" aria-hidden="true"></i>计算机网络笔记</p>
                <p class='content'>1.POST和GET的区别
GET和POST本质上就是TCP链接，并无差别
GET，它用于获取信息，它只是获取、查询数据，也就是说它不会修改服务器上的数据，从这点来讲，它是数据安全的。例如获取更...</p>
              </a>
            
            
              <a class='next' href='/2020/11/22/git%E7%89%88%E6%9C%AC%E6%8E%A7%E5%88%B6/'>
                <p class='title'>git版本控制<i class="fas fa-chevron-right" aria-hidden="true"></i></p>
                <p class='content'>版本控制
git init
创建本地仓库（版本库），当前目录下会有一个.git文件生成
.git文件就是用来记录当前版本库里内容变化的。






git add project.md
将我的...</p>
              </a>
            
          </div>
        
      </section>
    </article>
  

  
    <!-- 显示推荐文章和评论 -->



  <article class="post white-box reveal comments shadow">
    <section class="article typo">
      <p ct><i class='fas fa-comments'></i> 评论</p>
      
      
      
      
      
      
        <section id="comments">
          <div id="valine_container" class="valine_thread">
            <i class="fas fa-cog fa-spin fa-fw fa-2x"></i>
          </div>
        </section>
      
      
    </section>
  </article>


  




<!-- 根据页面mathjax变量决定是否加载MathJax数学公式js -->



  <script>
    window.subData = {
      title: '操作系统笔记',
      tools: true
    }
  </script>


</div>
<aside class='l_side'>
  
  

  
    
    



  <section class="widget toc-wrapper shadow desktop mobile" id="toc-div" >
    
  <header>
    
      <i class="fas fa-list fa-fw" aria-hidden="true"></i><span class='name'>本文目录</span>
    
  </header>


    <div class='content'>
        <ol class="toc"><li class="toc-item toc-level-2"><a class="toc-link" href="#1-阻塞-非阻塞IO-同步IO-异步IO，IO多路复用"><span class="toc-text">1.阻塞&#x2F;非阻塞IO,同步IO&#x2F;异步IO，IO多路复用</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#2-进程、线程、协程、守护进程"><span class="toc-text">2.进程、线程、协程、守护进程</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#进程"><span class="toc-text">进程</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#线程"><span class="toc-text">线程</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#协程"><span class="toc-text">协程</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#守护进程"><span class="toc-text">守护进程</span></a></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#3-进程状态"><span class="toc-text">3.进程状态</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#4-进程间通信"><span class="toc-text">4.进程间通信</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#1-管道"><span class="toc-text">1. 管道</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#2-消息队列"><span class="toc-text">2. 消息队列</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#3-共享内存"><span class="toc-text">3. 共享内存</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#4-信号量"><span class="toc-text">4. 信号量</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#5-信号"><span class="toc-text">5. 信号</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#6-socket"><span class="toc-text">6. socket</span></a></li></ol></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#5-死锁必要条件、解决死锁策略，写出死锁代码"><span class="toc-text">5.死锁必要条件、解决死锁策略，写出死锁代码</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#必要条件"><span class="toc-text">必要条件</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#预防死锁"><span class="toc-text">预防死锁</span></a></li></ol></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#6-分析静态链接的不足，以及动态链接的特点"><span class="toc-text">6.分析静态链接的不足，以及动态链接的特点</span></a><ol class="toc-child"><li class="toc-item toc-level-5"><a class="toc-link" href="#静态库："><span class="toc-text">静态库：</span></a></li><li class="toc-item toc-level-5"><a class="toc-link" href="#动态库："><span class="toc-text">动态库：</span></a></li></ol></li></ol></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#7-并行和并发"><span class="toc-text">7.并行和并发</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#并行："><span class="toc-text">并行：</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#并发："><span class="toc-text">并发：</span></a></li></ol></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#8-互斥锁、自旋锁、读写锁、悲观锁、乐观锁的应用场景"><span class="toc-text">8.互斥锁、自旋锁、读写锁、悲观锁、乐观锁的应用场景</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#互斥锁"><span class="toc-text">互斥锁</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#自旋锁"><span class="toc-text">自旋锁</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#读写锁"><span class="toc-text">读写锁</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#悲观锁"><span class="toc-text">悲观锁</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#乐观锁"><span class="toc-text">乐观锁</span></a></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#9-分页和分段"><span class="toc-text">9.分页和分段</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#分页存储的优缺点"><span class="toc-text">分页存储的优缺点</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#分段存储方式的优缺点"><span class="toc-text">分段存储方式的优缺点</span></a></li></ol></li><li class="toc-item toc-level-3"><a class="toc-link" href="#段页式存储"><span class="toc-text">段页式存储</span></a></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#10-虚拟内存的作用，分页系统实现虚拟内存原理"><span class="toc-text">10.虚拟内存的作用，分页系统实现虚拟内存原理</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#虚拟内存"><span class="toc-text">虚拟内存</span></a></li></ol></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#11-页面置换算法的原理"><span class="toc-text">11.页面置换算法的原理</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#最佳置换算法（理想最好的）"><span class="toc-text">最佳置换算法（理想最好的）</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#先进先出-FIFO-页面置换算法（性能最差的）"><span class="toc-text">先进先出(FIFO)页面置换算法（性能最差的）</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#LRU（最近最久未使用）置换算法"><span class="toc-text">LRU（最近最久未使用）置换算法</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#简单的Clock置换算法（LRU的近似算法）"><span class="toc-text">简单的Clock置换算法（LRU的近似算法）</span></a></li></ol></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#12-进程和线程的区别？"><span class="toc-text">12.进程和线程的区别？</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#13-内核态和用户态"><span class="toc-text">13.内核态和用户态</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#概念"><span class="toc-text">概念</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#内核态："><span class="toc-text">内核态：</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#用户态"><span class="toc-text">用户态</span></a></li></ol></li><li class="toc-item toc-level-3"><a class="toc-link" href="#指令划分"><span class="toc-text">指令划分</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#内核态和用户态的区别"><span class="toc-text">内核态和用户态的区别</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#用户态和内核态的切换"><span class="toc-text">用户态和内核态的切换</span></a></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#14-Reactor模式和Proactor模式"><span class="toc-text">14.Reactor模式和Proactor模式</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#在Reactor中实现读："><span class="toc-text">在Reactor中实现读：</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#在Proactor中实现读："><span class="toc-text">在Proactor中实现读：</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#总结："><span class="toc-text">总结：</span></a></li></ol></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#15-消息队列的作用？"><span class="toc-text">15.消息队列的作用？</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#解耦"><span class="toc-text">解耦</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#异步"><span class="toc-text">异步</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#削峰"><span class="toc-text">削峰</span></a></li></ol></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#16-线程越多越好吗"><span class="toc-text">16.线程越多越好吗</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#17-创建多少个线程合适呢？"><span class="toc-text">17.创建多少个线程合适呢？</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#CPU密集型"><span class="toc-text">CPU密集型</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#I-O密集型"><span class="toc-text">I&#x2F;O密集型</span></a></li></ol></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#18-零拷贝"><span class="toc-text">18.零拷贝</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#传统的文件传输"><span class="toc-text">传统的文件传输</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#零拷贝具体方法：https-mp-weixin-qq-com-s-P0IP6c-qFhuebwdwD8HM7w"><span class="toc-text">零拷贝具体方法：https:&#x2F;&#x2F;mp.weixin.qq.com&#x2F;s&#x2F;P0IP6c_qFhuebwdwD8HM7w</span></a></li></ol></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#19-线程安全"><span class="toc-text">19.线程安全</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#什么是线程安全"><span class="toc-text">什么是线程安全</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#多线程编程中的三个核心概念"><span class="toc-text">多线程编程中的三个核心概念</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#原子性"><span class="toc-text">原子性</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#可见性"><span class="toc-text">可见性</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#顺序性"><span class="toc-text">顺序性</span></a></li></ol></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#20-硬链接与软链接的区别"><span class="toc-text">20.硬链接与软链接的区别</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#概念："><span class="toc-text">概念：</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#区别："><span class="toc-text">区别：</span></a></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#21-僵尸进程与孤儿进程的区别"><span class="toc-text">21.僵尸进程与孤儿进程的区别</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#22-poll，epoll和select的优缺点"><span class="toc-text">22.poll，epoll和select的优缺点</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#select"><span class="toc-text">select</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#poll"><span class="toc-text">poll</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#epoll"><span class="toc-text">epoll</span></a></li></ol></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#23-物理内存、虚拟内存的区别、虚拟地址空间概念及区别"><span class="toc-text">23.物理内存、虚拟内存的区别、虚拟地址空间概念及区别</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#24-虚拟地址空间划分"><span class="toc-text">24.虚拟地址空间划分</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#1-保留区（受保护的地址）"><span class="toc-text">1. 保留区（受保护的地址）</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#2-代码段"><span class="toc-text">2. 代码段</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#3-数据段（-data段）"><span class="toc-text">3.数据段（.data段）</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#4-bss段"><span class="toc-text">4. .bss段</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#5-堆空间-heap"><span class="toc-text">5. 堆空间(heap)</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#6-内存映射段（共享库）"><span class="toc-text">6. 内存映射段（共享库）</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#7-栈空间-stack"><span class="toc-text">7. 栈空间(stack)</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#8-命令行参数"><span class="toc-text">8. 命令行参数</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#9-环境变量"><span class="toc-text">9. 环境变量</span></a></li></ol></li><li class="toc-item toc-level-3"><a class="toc-link" href="#虚拟地址空间的好处"><span class="toc-text">虚拟地址空间的好处</span></a></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#25-内核接受网络数据全过程"><span class="toc-text">25.内核接受网络数据全过程</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#26-epoll实现过程"><span class="toc-text">26.epoll实现过程</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#27-epoll模型水平触发、边沿触发优缺点对比"><span class="toc-text">27.epoll模型水平触发、边沿触发优缺点对比</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#水平触发优、缺点"><span class="toc-text">水平触发优、缺点</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#边沿触发优、缺点及应用场景"><span class="toc-text">边沿触发优、缺点及应用场景</span></a></li></ol></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#28-使用Linux-epoll模型，水平触发模式；当socket可写时，会不停的触发socket可写的事件，如何处理？"><span class="toc-text">28.使用Linux epoll模型，水平触发模式；当socket可写时，会不停的触发socket可写的事件，如何处理？</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#第一种最普遍的方式："><span class="toc-text">第一种最普遍的方式：</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#一种改进的方式："><span class="toc-text">一种改进的方式：</span></a></li></ol></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#29-惊群效应"><span class="toc-text">29.惊群效应</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#30-Linux每一个运行的程序（进程）操作系统都会在内存中为其分配一个0-4G的地址空间（虚拟地址空间）。cpu为什么要使用虚拟地址空间与物理地址空间映射？解决了什么样的问题"><span class="toc-text">30.Linux每一个运行的程序（进程）操作系统都会在内存中为其分配一个0~4G的地址空间（虚拟地址空间）。cpu为什么要使用虚拟地址空间与物理地址空间映射？解决了什么样的问题</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#31-查看端口被占用的命令"><span class="toc-text">31.查看端口被占用的命令</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#lsof"><span class="toc-text">lsof</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#netstat"><span class="toc-text">netstat</span></a></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#32-Linux常用的排查cpu、io、网络、内存常用的工具"><span class="toc-text">32.Linux常用的排查cpu、io、网络、内存常用的工具</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#1-自旋锁通常会出现哪些问题"><span class="toc-text">1. 自旋锁通常会出现哪些问题?</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#2-自旋锁和其他锁有什么不同？"><span class="toc-text">2. 自旋锁和其他锁有什么不同？</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#3-自旋锁有哪些优点？"><span class="toc-text">3. 自旋锁有哪些优点？</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#4-多线程不加锁出现数据紊乱的例子"><span class="toc-text">4. 多线程不加锁出现数据紊乱的例子</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#—————————————-如有错误，欢迎指正！—————————————"><span class="toc-text">—————————————-如有错误，欢迎指正！—————————————-</span></a></li></ol></li></ol></li></ol>
    </div>
  </section>


  


</aside>


  
  <footer class="clearfix">
    <br><br>
    
      
        <div class="aplayer-container">
          

  
    <meting-js
      theme='#1BCDFC'
      autoplay='false'
      volume='0.7'
      loop='all'
      order='random'
      fixed='false'
      list-max-height='340px'
      server='netease'
      type='playlist'
      id='2985312517'
      list-folded='true'>
    </meting-js>
  


        </div>
      
    
      
        <br>
        <div class="social-wrapper">
          
            
              <a href="mailto:1342736410@qq.com"
                class="social fas fa-envelope flat-btn"
                target="_blank"
                rel="external nofollow noopener noreferrer">
              </a>
            
          
            
              <a href="https://github.com/CyChan811"
                class="social fab fa-github flat-btn"
                target="_blank"
                rel="external nofollow noopener noreferrer">
              </a>
            
          
            
              <a href="http://wpa.qq.com/msgrd?v=3&amp;uin=1342736410&amp;site=qq&amp;menu=yes"
                class="social fab fa-qq flat-btn"
                target="_blank"
                rel="external nofollow noopener noreferrer">
              </a>
            
          
            
              <a href="http://music.163.com/playlist?id=2985312517&amp;userid=1980577201"
                class="social fas fa-headphones-alt flat-btn"
                target="_blank"
                rel="external nofollow noopener noreferrer">
              </a>
            
          
        </div>
      
    
      
        <div><p>博客内容遵循 <a href="https://creativecommons.org/licenses/by-nc-sa/4.0/deed.zh" target="_blank" rel="noopener">署名-非商业性使用-相同方式共享 4.0 国际 (CC BY-NC-SA 4.0) 协议</a></p>
        </div>
      
    
      
        本站使用
        <a href="https://volantis.js.org/" target="_blank" class="codename">volantis</a>
        作为主题，总访问量为
          <span id="busuanzi_value_site_pv"><i class="fas fa-circle-notch fa-spin fa-fw" aria-hidden="true"></i></span>
          次
      
    
      
        
      
    
      
      <br>
        <span id="timeDate"></span><span id="times"></span>
        <div class='copyright'>
          <a href="https://cychan811.gitee.io">Copyright © 2017-2020 CyChan</a>
        </div>
      
    
    
  </footer>


      <script>
      var now = new Date(); 
      function createtime() { 
          var grt= new Date("07/01/2020 12:00:00");//在此处修改你的建站时间，格式：月/日/年 时:分:秒
          now.setTime(now.getTime()+250); 
          days = (now - grt ) / 1000 / 60 / 60 / 24; dnum = Math.floor(days); 
          hours = (now - grt ) / 1000 / 60 / 60 - (24 * dnum); hnum = Math.floor(hours); 
          if(String(hnum).length ==1 ){hnum = "0" + hnum;} minutes = (now - grt ) / 1000 /60 - (24 * 60 * dnum) - (60 * hnum); 
          mnum = Math.floor(minutes); if(String(mnum).length ==1 ){mnum = "0" + mnum;} 
          seconds = (now - grt ) / 1000 - (24 * 60 * 60 * dnum) - (60 * 60 * hnum) - (60 * mnum); 
          snum = Math.round(seconds); if(String(snum).length ==1 ){snum = "0" + snum;} 
          document.getElementById("timeDate").innerHTML = "本站已安全运行 "+dnum+" 天 "+ hnum + " 小时 " + mnum + " 分 " + snum + " 秒"; 
      } 
        setInterval("createtime()",250);
     </script>
<script>setLoadingBarProgress(80);</script>


      <script>setLoadingBarProgress(60);</script>
    </div>
    <a class="s-top fas fa-arrow-up fa-fw" href='javascript:void(0)'></a>
  </div>
  
<script src="https://cdn.jsdelivr.net/npm/jquery@3.4/dist/jquery.min.js"></script>


  <script>
    
    var SEARCH_SERVICE = "hexo" || "hexo";
    var ROOT = "/" || "/";
    if (!ROOT.endsWith('/')) ROOT += '/';
  </script>





  <script async src="https://cdn.jsdelivr.net/gh/xaoxuu/cdn-volantis@2/js/instant_page.js" type="module" defer integrity="sha384-OeDn4XE77tdHo8pGtE1apMPmAipjoxUQ++eeJa6EtJCfHlvijigWiJpD7VDPWXV1"></script>


  <script src="https://cdn.jsdelivr.net/npm/scrollreveal@4.0.6/dist/scrollreveal.min.js"></script>
  <script type="text/javascript">
    $(function() {
      ScrollReveal().reveal('.l_main .reveal', {
        distance: '8px',
        duration: '800',
        interval: '100',
        scale: '1'
      });
    });
  </script>


  
<script src="https://cdn.jsdelivr.net/npm/node-waves@0.7.6/dist/waves.min.js"></script>

  <script type="text/javascript">
    $(function() {
      Waves.attach('.flat-btn', ['waves-button']);
      Waves.attach('.float-btn', ['waves-button', 'waves-float']);
      Waves.attach('.float-btn-light', ['waves-button', 'waves-float', 'waves-light']);
      Waves.attach('.flat-box', ['waves-block']);
      Waves.attach('.float-box', ['waves-block', 'waves-float']);
      Waves.attach('.waves-image');
      Waves.init();
    });
  </script>


  <script defer src="https://cdn.jsdelivr.net/gh/xaoxuu/cdn-busuanzi@2.3/js/busuanzi.pure.mini.js"></script>



  
  
  
    
<script src="https://cdn.jsdelivr.net/npm/jquery-backstretch@2.1.18/jquery.backstretch.min.js"></script>

    <script type="text/javascript">
      $(function(){
        var imgs=["https://cdn.jsdelivr.net/gh/xaoxuu/cdn-wallpaper/abstract/41F215B9-261F-48B4-80B5-4E86E165259E.jpeg", "https://cdn.jsdelivr.net/gh/xaoxuu/cdn-wallpaper/abstract/BBC19066-E176-47C2-9D22-48C81EE5DF6B.jpeg", "https://cdn.jsdelivr.net/gh/xaoxuu/cdn-wallpaper/abstract/B18FCBB3-67FD-48CC-B4F3-457BA145F17A.jpeg", "https://ss0.bdstatic.com/70cFuHSh_Q1YnxGkpoWK1HF6hhy/it/u=3799510479,4073126189&fm=26&gp=0.jpg", "https://ss3.bdstatic.com/70cFv8Sh_Q1YnxGkpoWK1HF6hhy/it/u=2883764232,1534773763&fm=26&gp=0.jpg", "https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1593783783483&di=3ad7e4713031f3e60c3a8bab2c2aae02&imgtype=0&src=http%3A%2F%2Fcz-video-photo.oss-cn-beijing.aliyuncs.com%2F20191015%2F7d47db92bbe2627ecd035976a61463cb_00001.jpg", "https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1593783631802&di=0616aa53378b2de7816f786a97c75bfe&imgtype=0&src=http%3A%2F%2Fpic1.win4000.com%2Fwallpaper%2F2018-01-10%2F5a55c62f9a142.jpg", "https://cdn.jsdelivr.net/gh/xaoxuu/cdn-wallpaper/abstract/00E0F0ED-9F1C-407A-9AA6-545649D919F4.jpeg", "https://cdn.jsdelivr.net/gh/zyoushuo/Blog/images/bj1.jpg", "https://gitee.com/CyChan811/BlogImage/raw/master/img/1 (2).png", "https://gitee.com/CyChan811/BlogImage/raw/master/img/t01e2fa7120d00d62da.jpg", "https://gitee.com/CyChan811/BlogImage/raw/master/img/1 (19).jpg"];
        if ('true' == 'true') {
          function shuffle(arr){
            /*From countercurrent-time*/
            var n = arr.length;
            while(n--) {
              var index = Math.floor(Math.random() * n);
              var temp = arr[index];
              arr[index] = arr[n];
              arr[n] = temp;
            }
          }
          shuffle(imgs);
        }
        if ('') {
          $('').backstretch(
            imgs,
          {
            duration: "20000",
            fade: "1500"
          });
        } else {
          $.backstretch(
            imgs,
          {
            duration: "20000",
            fade: "1500"
          });
        }
      });
    </script>
  



  
    
<script src="https://cdn.jsdelivr.net/npm/aplayer@1.10/dist/APlayer.min.js"></script>

  
    
<script src="https://cdn.jsdelivr.net/npm/meting@2.0/dist/Meting.min.js"></script>

  









  
    
<script src="https://cdn.jsdelivr.net/gh/HCLonely/Valine@latest/dist/Valine.min.js"></script>

  
  <script>
  var GUEST_INFO = ['nick','mail','link'];
  var meta = 'nick,mail,link'.split(',').filter(function(item){
    return GUEST_INFO.indexOf(item) > -1
  });
  var REQUIRED_FIELDS = ['nick','mail','link'];
  var requiredFields = 'nick,mail'.split(',').filter(function(item){
    return REQUIRED_FIELDS.indexOf(item) > -1
  });
  var valine = new Valine();
  var master = 'f03ef4cd1728b39a2b1d24cb0c7c4ac8'.split(',');
  function emoji(path, idx, ext) {
      return path + "/" + path + "-" + idx + "." + ext;
  }
  var emojiMaps = {};
  for (var i = 1; i <= 54; i++) {
    emojiMaps['tieba-' + i] = emoji('tieba', i, 'png');
  }
  for (var i = 1; i <= 101; i++) {
    emojiMaps['qq-' + i] = emoji('qq', i, 'gif');
  }
  for (var i = 1; i <= 116; i++) {
    emojiMaps['aru-' + i] = emoji('aru', i, 'gif');
  }
  for (var i = 1; i <= 125; i++) {
    emojiMaps['twemoji-' + i] = emoji('twemoji', i, 'png');
  }
  for (var i = 1; i <= 4; i++) {
    emojiMaps['weibo-' + i] = emoji('weibo', i, 'png');
  }
  valine.init({
    el: '#valine_container',
    meta: meta,
    
    appId: "COclWTHE9FOx0Kp5LQxypRuw-gzGzoHsz",
    appKey: "IFkkcvnaeUWqUUYoWqCJ5hUY",
    placeholder: "ヾﾉ≧∀≦)o来啊，快活啊!~",
    pageSize:'10',
    avatar:'robohash',
    lang:'zh-cn',
    visitor: 'true',
    highlight: 'true',
    mathJax: 'false',
    enableQQ: 'true',
    requiredFields: requiredFields,
    emojiCDN: 'https://cdn.jsdelivr.net/gh/xaoxuu/cdn-assets/emoji/valine/',
    emojiMaps: emojiMaps,
    master: master
  })
  </script>





  
<script src="/js/app.js"></script>



  
<script src="https://cdn.jsdelivr.net/gh/xaoxuu/cdn-volantis@2.6.5/js/search.js"></script>



  
<script src="https://cdn.jsdelivr.net/gh/xaoxuu/cdn-volantis@2/js/comment_typing.js"></script>






<!-- 复制 -->

  <script src="https://cdn.jsdelivr.net/npm/clipboard@2/dist/clipboard.min.js"></script>
<script>
  function wait(callback, seconds) {
    var timelag = null;
    timelag = window.setTimeout(callback, seconds);
  }
  !function (e, t, a) {
    var initCopyCode = function(){
      var copyHtml = '';
      copyHtml += '<button class="btn-copy" data-clipboard-snippet="">';
      copyHtml += '<i class="fas fa-copy"></i><span>COPY</span>';
      copyHtml += '</button>';
      $(".highlight .code pre").before(copyHtml);
      $(".article pre code").before(copyHtml);
      var clipboard = new ClipboardJS('.btn-copy', {
        target: function(trigger) {
          return trigger.nextElementSibling;
        }
      });
      clipboard.on('success', function(e) {
        let $btn = $(e.trigger);
        $btn.addClass('copied');
        let $icon = $($btn.find('i'));
        $icon.removeClass('fa-copy');
        $icon.addClass('fa-check-circle');
        let $span = $($btn.find('span'));
        $span[0].innerText = 'COPIED';
        
        wait(function () { // 等待两秒钟后恢复
          $icon.removeClass('fa-check-circle');
          $icon.addClass('fa-copy');
          $span[0].innerText = 'COPY';
        }, 2000);
      });
      clipboard.on('error', function(e) {
        e.clearSelection();
        let $btn = $(e.trigger);
        $btn.addClass('copy-failed');
        let $icon = $($btn.find('i'));
        $icon.removeClass('fa-copy');
        $icon.addClass('fa-times-circle');
        let $span = $($btn.find('span'));
        $span[0].innerText = 'COPY FAILED';
        
        wait(function () { // 等待两秒钟后恢复
          $icon.removeClass('fa-times-circle');
          $icon.addClass('fa-copy');
          $span[0].innerText = 'COPY';
        }, 2000);
      });
    }
    initCopyCode();
  }(window, document);
</script>




<!-- fancybox -->
<script src="https://cdn.jsdelivr.net/gh/fancyapps/fancybox@3.5.7/dist/jquery.fancybox.min.js"></script>
<script>
  function pjax_fancybox() {
    $(".article-entry").find("img").not('.inline').not('a img').each(function () { //渲染 fancybox
      var element = document.createElement("a"); // a 标签
      $(element).attr("pjax-fancybox", "");  // 过滤 pjax
      $(element).attr("href", $(this).attr("src"));
      if ($(this).attr("data-original")) {
        $(element).attr("href", $(this).attr("data-original"));
      }
      $(element).attr("data-fancybox", "images");
      var caption = "";   // 描述信息
      if ($(this).attr('alt')) {  // 标准 markdown 描述信息
        $(element).attr('data-caption', $(this).attr('alt'));
        caption = $(this).attr('alt');
      }
      var div = document.createElement("div");
      $(div).addClass("fancybox");
      $(this).wrap(div); // 最外层套 div ，其实主要作用还是 class 样式
      var span = document.createElement("span");
      $(span).addClass("image-caption");
      $(span).text(caption); // 加描述
      $(this).after(span);  // 再套一层描述
      $(this).wrap(element);  // 最后套 a 标签
    })
    $(".article-entry").find("img").fancybox({
      selector: '[data-fancybox="images"]',
      hash: false,
      loop: false,
      closeClick: true,
      helpers: {
        overlay: {closeClick: true}
      },
      buttons: [
        "zoom",
        "close"
      ]
    });
  };
  $(function () {
    pjax_fancybox();
  });
</script>





  <script>setLoadingBarProgress(100);</script>
  <script src="https://cdn.jsdelivr.net/gh/zyoushuo/Blog/hexo/js/mouse_click.js"></script>
</body>
</html>
